@dxos/plugin-thread 0.8.4-main.5acf9ea → 0.8.4-main.66e292d

package/src/capabilities/intent-resolver.ts

@@ -2,32 +2,36 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Effect } from 'effect';
+import * as Effect from 'effect/Effect';
 
-import { Capabilities, contributes, createIntent, createResolver, type PluginContext } from '@dxos/app-framework';
+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 { fullyQualifiedId, getSpace, Ref } from '@dxos/react-client/echo';
-import { AnchoredTo, DataType } from '@dxos/schema';
+import { SpaceAction } from '@dxos/plugin-space/types';
+import { Ref, getSpace } from '@dxos/react-client/echo';
+import { Collection } from '@dxos/schema';
+import { AnchoredTo, Message, Thread } from '@dxos/types';
+
+import { meta } from '../meta';
+import { Channel, ThreadAction } from '../types';
 
 import { ThreadCapabilities } from './capabilities';
-import { THREAD_PLUGIN } from '../meta';
-import { ChannelType, ThreadAction, ThreadType } from '../types';
 
 export default (context: PluginContext) =>
   contributes(Capabilities.IntentResolver, [
     createResolver({
-      intent: ThreadAction.OnSpaceCreated,
-      resolve: ({ space, rootCollection }) =>
+      intent: ThreadAction.OnCreateSpace,
+      resolve: ({ space, isDefault, rootCollection }) =>
         Effect.gen(function* () {
+          if (isDefault) {
+            return;
+          }
+
           const { dispatch } = context.getCapability(Capabilities.IntentDispatcher);
-          const { object: collection } = yield* dispatch(
-            createIntent(CollectionAction.CreateQueryCollection, { typename: Type.getTypename(ChannelType) }),
-          );
+          const collection = Collection.makeManaged({ key: Type.getTypename(Channel.Channel) });
           rootCollection.objects.push(Ref.make(collection));
 
           const { object: channel } = yield* dispatch(
@@ -40,18 +44,14 @@ export default (context: PluginContext) =>
       intent: ThreadAction.CreateChannel,
       resolve: ({ name }) => ({
         data: {
-          object: Obj.make(ChannelType, {
-            name,
-            defaultThread: Ref.make(Obj.make(ThreadType, { messages: [], status: 'active' })),
-            threads: [],
-          }),
+          object: Channel.make({ name }),
         },
       }),
     }),
     createResolver({
       intent: ThreadAction.CreateChannelThread,
       resolve: ({ channel }) => {
-        const thread = Obj.make(ThreadType, { messages: [], status: 'active' });
+        const thread = Thread.make({ status: 'active' });
         channel.threads.push(Ref.make(thread));
         return {
           data: {
@@ -64,13 +64,10 @@ export default (context: PluginContext) =>
     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, {
+        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,
@@ -85,7 +82,7 @@ export default (context: PluginContext) =>
 
         return {
           intents: [
-            createIntent(ThreadAction.Select, { current: fullyQualifiedId(thread) }),
+            createIntent(ThreadAction.Select, { current: Obj.getDXN(thread).toString() }),
             createIntent(DeckAction.ChangeCompanion, {
               primary: subjectId,
               companion: `${subjectId}${ATTENDABLE_PATH_SEPARATOR}comments`,
@@ -130,9 +127,9 @@ export default (context: PluginContext) =>
     createResolver({
       intent: ThreadAction.Delete,
       resolve: async ({ subject, anchor, thread: _thread }, undo) => {
-        const thread = _thread ?? (Relation.getSource(anchor) as ThreadType);
+        const thread = _thread ?? (Relation.getSource(anchor) as Thread.Thread);
         const { state } = context.getCapability(ThreadCapabilities.MutableState);
-        const subjectId = fullyQualifiedId(subject);
+        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.
@@ -156,7 +153,7 @@ export default (context: PluginContext) =>
 
           return {
             undoable: {
-              message: ['thread deleted label', { ns: THREAD_PLUGIN }],
+              message: ['thread deleted label', { ns: meta.id }],
               data: { thread, anchor },
             },
             intents: [
@@ -192,14 +189,13 @@ export default (context: PluginContext) =>
     createResolver({
       intent: ThreadAction.AddMessage,
       resolve: ({ anchor, subject, sender, text }) => {
-        const thread = Relation.getSource(anchor) as ThreadType;
+        const thread = Relation.getSource(anchor) as Thread.Thread;
         const { state } = context.getCapability(ThreadCapabilities.MutableState);
-        const subjectId = fullyQualifiedId(subject);
+        const subjectId = Obj.getDXN(subject).toString();
         const space = getSpace(subject);
         invariant(space, 'Space not found');
-        const intents = [];
 
-        const message = Obj.make(DataType.Message, {
+        const message = Obj.make(Message.Message, {
           created: new Date().toISOString(),
           sender,
           blocks: [{ _tag: 'text', text }],
@@ -208,6 +204,7 @@ export default (context: PluginContext) =>
         });
         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.
@@ -218,7 +215,7 @@ export default (context: PluginContext) =>
           intents.push(
             createIntent(SpaceAction.AddRelation, {
               space,
-              schema: AnchoredTo,
+              schema: AnchoredTo.AnchoredTo,
               source: thread,
               target: subject,
               fields: { anchor: draft.anchor },
@@ -254,7 +251,7 @@ export default (context: PluginContext) =>
     createResolver({
       intent: ThreadAction.DeleteMessage,
       resolve: ({ subject, anchor, messageId, message, messageIndex }, undo) => {
-        const thread = Relation.getSource(anchor) as ThreadType;
+        const thread = Relation.getSource(anchor) as Thread.Thread;
         const space = getSpace(subject);
         invariant(space, 'Space not found');
 
@@ -276,7 +273,7 @@ export default (context: PluginContext) =>
 
           return {
             undoable: {
-              message: ['message deleted label', { ns: THREAD_PLUGIN }],
+              message: ['message deleted label', { ns: meta.id }],
               data: { message, messageIndex },
             },
             intents: [

package/src/capabilities/markdown.ts

@@ -4,15 +4,16 @@
 
 import { EditorView } from '@codemirror/view';
 
-import { Capabilities, contributes, createIntent, type PluginContext } from '@dxos/app-framework';
+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 { fullyQualifiedId } from '@dxos/react-client/echo';
-import { commentClickedEffect, commentsState, type EditorState, overlap } from '@dxos/react-ui-editor';
+import { type EditorState, commentClickedEffect, commentsState, overlap } from '@dxos/react-ui-editor';
 
-import { ThreadCapabilities } from './capabilities';
 import { threads } from '../extensions';
 
+import { ThreadCapabilities } from './capabilities';
+
 export default (context: PluginContext) =>
   contributes(MarkdownCapabilities.Extensions, [
     ({ document: doc }) => {
@@ -21,17 +22,19 @@ export default (context: PluginContext) =>
       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[fullyQualifiedId(doc)] = selectionOverlapsComment(update.state);
+          state.toolbar[Obj.getDXN(doc).toString()] = selectionOverlapsComment(update.state);
         }
       });
     },
     ({ document: doc }) => {
+      if (!doc) return [];
       const { dispatchPromise: dispatch } = context.getCapability(Capabilities.IntentDispatcher);
-      const id = fullyQualifiedId(doc);
+      const id = Obj.getDXN(doc).toString();
 
       return EditorView.updateListener.of((update) => {
         update.transactions.forEach((transaction) => {

package/src/capabilities/react-root.tsx

@@ -7,11 +7,11 @@ import React from 'react';
 import { Capabilities, contributes } from '@dxos/app-framework';
 
 import { Call } from '../components';
-import { THREAD_PLUGIN } from '../meta';
+import { meta } from '../meta';
 
 export default () => {
   return contributes(Capabilities.ReactRoot, {
-    id: THREAD_PLUGIN,
+    id: meta.id,
     root: () => <Call.Audio />,
   });
 };

package/src/capabilities/react-surface.tsx

@@ -4,36 +4,39 @@
 
 import React from 'react';
 
-import { Capabilities, contributes, createSurface, useCapability } from '@dxos/app-framework';
+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 { Thread } from '@dxos/types';
 
-import { ThreadCapabilities } from './capabilities';
 import {
-  CallSidebar,
   CallDebugPanel,
+  CallSidebar,
   ChannelContainer,
-  ThreadComplementary,
-  ThreadSettings,
   ChatContainer,
+  ThreadCompanion,
+  ThreadSettings,
 } from '../components';
-import { THREAD_PLUGIN } from '../meta';
-import { ChannelType, ThreadType, type ThreadSettingsProps } from '../types';
+import { meta } from '../meta';
+import { Channel, type ThreadSettingsProps } from '../types';
+
+import { ThreadCapabilities } from './capabilities';
 
 export default () =>
   contributes(Capabilities.ReactSurface, [
     createSurface({
-      id: `${THREAD_PLUGIN}/channel`,
+      id: `${meta.id}/channel`,
       role: 'article',
-      filter: (data): data is { subject: ChannelType } => Obj.instanceOf(ChannelType, data.subject),
-      component: ({ data: { subject: channel }, role }) => <ChannelContainer channel={channel} role={role} />,
+      filter: (data): data is { subject: Channel.Channel } => Obj.instanceOf(Channel.Channel, data.subject),
+      component: ({ data: { subject }, role }) => <ChannelContainer channel={subject} role={role} />,
     }),
     createSurface({
-      id: `${THREAD_PLUGIN}/chat-companion`,
+      id: `${meta.id}/chat-companion`,
       role: 'article',
-      filter: (data): data is { companionTo: ChannelType; subject: 'chat' } =>
-        Obj.instanceOf(ChannelType, data.companionTo) && data.subject === 'chat',
+      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;
@@ -45,40 +48,40 @@ export default () =>
       },
     }),
     createSurface({
-      id: `${THREAD_PLUGIN}/thread`,
+      id: `${meta.id}/thread`,
       role: 'article',
-      filter: (data): data is { subject: ThreadType } => Obj.instanceOf(ThreadType, data.subject),
-      component: ({ data: { subject: thread } }) => {
-        const space = getSpace(thread);
-        if (!space || !thread) {
+      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={thread} space={space} />;
+        return <ChatContainer thread={subject} space={space} />;
       },
     }),
     createSurface({
-      id: `${THREAD_PLUGIN}/comments`,
+      id: `${meta.id}/comments`,
       role: 'article',
-      filter: (data): data is { companionTo: { threads: Ref.Ref<ThreadType>[] } } =>
+      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 }) => <ThreadComplementary subject={data.companionTo} />,
+      component: ({ data }) => <ThreadCompanion subject={data.companionTo} />,
     }),
     createSurface({
-      id: `${THREAD_PLUGIN}/plugin-settings`,
+      id: `${meta.id}/plugin-settings`,
       role: 'article',
       filter: (data): data is { subject: SettingsStore<ThreadSettingsProps> } =>
-        data.subject instanceof SettingsStore && data.subject.prefix === THREAD_PLUGIN,
+        data.subject instanceof SettingsStore && data.subject.prefix === meta.id,
       component: ({ data: { subject } }) => <ThreadSettings settings={subject.value} />,
     }),
     createSurface({
-      id: `${THREAD_PLUGIN}/assistant`,
+      id: `${meta.id}/assistant`,
       role: 'deck-companion--active-call',
       component: () => <CallSidebar />,
     }),
     createSurface({
-      id: `${THREAD_PLUGIN}/devtools-overview`,
+      id: `${meta.id}/devtools-overview`,
       role: 'devtools-overview',
       component: () => {
         const call = useCapability(ThreadCapabilities.CallManager);

package/src/capabilities/repair.ts

@@ -0,0 +1,40 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { contributes } 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';
+
+export default () =>
+  contributes(SpaceCapabilities.Repair, async ({ space, isDefault }) => {
+    if (isDefault) {
+      return;
+    }
+
+    await ensureSystemCollection(space);
+  });
+
+/**
+ * Ensure the root collection has a system collection for Channels.
+ */
+const ensureSystemCollection = async (space: Space) => {
+  const rootCollection: Collection.Collection = await space.properties[Collection.Collection.typename]?.load();
+  if (!rootCollection) {
+    return;
+  }
+
+  const objects = await Promise.all(rootCollection.objects.map((ref) => ref.load()));
+  const channels = objects.find(
+    (object) => Obj.instanceOf(Collection.Managed, object) && object.key === Type.getTypename(Channel.Channel),
+  );
+  if (channels) {
+    return;
+  }
+
+  rootCollection.objects.push(Ref.make(Collection.makeManaged({ key: Type.getTypename(Channel.Channel) })));
+};

package/src/capabilities/state.ts

@@ -5,9 +5,10 @@
 import { contributes } from '@dxos/app-framework';
 import { live } from '@dxos/live-object';
 
-import { ThreadCapabilities } from './capabilities';
 import { type ThreadState, type ViewStore } from '../types';
 
+import { ThreadCapabilities } from './capabilities';
+
 const initialViewState = { showResolvedThreads: false };
 
 export default () => {

package/src/components/Call/Call.tsx

@@ -2,17 +2,18 @@
 // Copyright 2025 DXOS.org
 //
 
-import React, { type PropsWithChildren, type FC } from 'react';
+import React, { type FC, type PropsWithChildren } from 'react';
 
-import { useCapability } from '@dxos/app-framework';
+import { useCapability } from '@dxos/app-framework/react';
 import { type ThemedClassName } from '@dxos/react-ui';
 
-import { Toolbar, type ToolbarProps } from './Toolbar';
 import { ThreadCapabilities } from '../../capabilities';
 import { useDebugMode } from '../../hooks';
 import { AudioStream } from '../Media';
 import { ParticipantGrid } from '../Participant';
 
+import { Toolbar, type ToolbarProps } from './Toolbar';
+
 //
 // Root
 //

package/src/components/Call/Toolbar.tsx

@@ -4,15 +4,15 @@
 
 import React from 'react';
 
-import { useAppGraph, useCapability } from '@dxos/app-framework';
-import { useNode, useActions } from '@dxos/plugin-graph';
-import { fullyQualifiedId } from '@dxos/react-client/echo';
+import { useAppGraph, useCapability } from '@dxos/app-framework/react';
+import { Obj } from '@dxos/echo';
+import { useActions, useNode } from '@dxos/plugin-graph';
 import {
   Icon,
   IconButton,
   type IconButtonProps,
+  Toolbar as NaturalToolbar,
   type ThemedClassName,
-  Toolbar as NativeToolbar,
   toLocalizedString,
   useTranslation,
 } from '@dxos/react-ui';
@@ -20,10 +20,10 @@ import { groupHoverControlItemWithTransition, mx } from '@dxos/react-ui-theme';
 
 import { ThreadCapabilities } from '../../capabilities';
 import { meta } from '../../meta';
-import { type ChannelType } from '../../types';
+import { type Channel } from '../../types';
 
 export type ToolbarProps = ThemedClassName<{
-  channel?: ChannelType;
+  channel?: Channel.Channel;
   participants?: number;
   autoHideControls?: boolean;
   isInRoom?: boolean;
@@ -45,7 +45,7 @@ export const Toolbar = ({
   const call = useCapability(ThreadCapabilities.CallManager);
 
   // Channel app graph node.
-  const node = useNode(graph, channel && fullyQualifiedId(channel));
+  const node = useNode(graph, channel && Obj.getDXN(channel).toString());
   const actions = useActions(graph, node?.id).filter((action) => action.properties.disposition === 'toolbar');
 
   // Screen sharing.
@@ -56,7 +56,7 @@ export const Toolbar = ({
   // TODO(wittjosiah): In order to use toolbar, need to update to actually use the graph action callbacks directly.
   return (
     <div className={mx('z-20 flex justify-center m-8', autoHideControls && groupHoverControlItemWithTransition)}>
-      <NativeToolbar.Root classNames={['p-2 bg-modalSurface rounded-md shadow-md', classNames]}>
+      <NaturalToolbar.Root classNames={['p-2 bg-modalSurface rounded-md shadow-md', classNames]}>
         <ToggleButton
           active={call.media.audioEnabled}
           state={{
@@ -95,7 +95,7 @@ export const Toolbar = ({
             <Icon icon='ph--users--regular' size={4} />
             <div>{participants}</div>
           </div>
-        )) || <NativeToolbar.Separator variant='gap' />}
+        )) || <NaturalToolbar.Separator variant='gap' />}
 
         {call.joined && (
           <>
@@ -151,7 +151,7 @@ export const Toolbar = ({
         ) : (
           <IconButton variant='primary' icon='ph--phone-incoming--regular' label={t('join call')} onClick={onJoin} />
         )}
-      </NativeToolbar.Root>
+      </NaturalToolbar.Root>
     </div>
   );
 };