@dxos/plugin-thread 0.8.4-main.fd6878d → 0.9.0

package/src/translations.ts

@@ -2,94 +2,96 @@
 // Copyright 2023 DXOS.org
 //
 
+import { Type } from '@dxos/echo';
 import { type Resource } from '@dxos/react-ui';
+import { Channel } from '@dxos/types';
 
-import { meta } from './meta';
-import { ChannelType } from './types';
+import { meta } from '#meta';
 
 export const translations = [
   {
     'en-US': {
-      [ChannelType.typename]: {
-        'typename label': 'Channel',
-        'typename label_zero': 'Channels',
-        'typename label_one': 'Channel',
-        'typename label_other': 'Channels',
-        'object name placeholder': 'New channel',
-        'rename object label': 'Rename channel',
-        'delete object label': 'Delete channel',
+      // TODO(burdon): Thread.
+      [Type.getTypename(Channel.Channel)]: {
+        'typename.label': 'Channel',
+        'typename.label_zero': 'Channels',
+        'typename.label_one': 'Channel',
+        'typename.label_other': 'Channels',
+        'object-name.placeholder': 'New channel',
+        'add-object.label': 'Add channel',
+        'rename-object.label': 'Rename channel',
+        'delete-object.label': 'Delete channel',
+        'object-deleted.label': 'Channel deleted',
       },
       [meta.id]: {
-        'plugin name': 'Chat',
-        'channel title label': 'Title',
-        'message placeholder': 'Reply…',
-        'activity message': 'Processing…',
-        'anonymous label': 'Anonymous',
-        'delete message block label': 'Delete message block',
-        'detached thread label': 'Referenced content was removed',
-        'delete thread label': 'Delete thread',
-        'resolve thread label': 'Resolve thread',
-        'thread deleted label': 'Thread deleted',
-        'message deleted label': 'Message deleted',
-        'comments heading': 'Comments',
-        'chat heading': 'Chat',
-        'draft button': 'DRAFT',
-        'no comments title': 'Comments',
-        'no comments message':
+        'plugin.name': 'Chat',
+        'channel-title.label': 'Title',
+        'message.placeholder': 'Reply…',
+        'activity.message': 'Processing…',
+        'anonymous.label': 'Anonymous',
+        'delete-message-block.label': 'Delete message block',
+        'detached-thread.label': 'Referenced content was removed',
+        'delete-thread.label': 'Delete thread',
+        'resolve-thread.label': 'Resolve thread',
+        'thread-deleted.label': 'Thread deleted',
+        'message-deleted.label': 'Message deleted',
+        'comments.heading': 'Comments',
+        'chat.heading': 'Chat',
+        'draft.button': 'DRAFT',
+        'no-comments.title': 'Comments',
+        'no-comments.message':
           'Click on the <commentIcon></commentIcon> button in the document toolbar to create a comment thread on the selected text.',
-        'toggle show resolved': 'Show resolved',
-        'unnamed object threads label': 'Threads',
-        'mark as resolved label': 'Mark as resolved',
-        'mark as unresolved label': 'Mark as unresolved',
-        'save message label': 'Save',
-        'edit message label': 'Edit',
-        'delete message label': 'Delete message',
-        'open comments panel label': 'Show Comments',
-        'comments label': 'Comments',
-        'show all label': 'All comments',
-        'show unresolved label': 'Unresolved comments',
+        'toggle-show-resolved.label': 'Show resolved',
+        'unnamed-object-threads.label': 'Threads',
+        'mark-as-resolved.label': 'Mark as resolved',
+        'mark-as-unresolved.label': 'Mark as unresolved',
+        'save-message.label': 'Save',
+        'edit-message.label': 'Edit',
+        'delete-message.label': 'Delete message',
+        'accept-proposal.label': 'Accept proposal',
+        'open-comments-panel.label': 'Show Comments',
+        'comments.label': 'Comments',
+        'show-all.label': 'All comments',
+        'show-unresolved.label': 'Unresolved comments',
+        'add-comment.label': 'Add comment',
 
-        'channel companion label': 'Channel',
-        'call panel label': 'Active Call',
+        'channel-companion.label': 'Channel',
+        'call-panel.label': 'Active Call',
 
-        'display name label': 'Display name',
-        'display name description': 'Set your display name before joining a meeting.',
-        'display name input placeholder': 'Enter your name',
-        'set display name label': 'Continue',
+        'display-name.label': 'Display name',
+        'display-name.description': 'Set your display name before joining a meeting.',
+        'display-name-input.placeholder': 'Enter your name',
+        'set-display-name.label': 'Continue',
 
-        'call tab label': 'Call',
-        'meeting status title': 'Meeting',
-        'share meeting link label': 'Share meeting',
-        'show webrtc stats title': 'Detailed WebRTC Stats',
+        'call-tab.label': 'Call',
+        'meeting-status.title': 'Calls',
+        'share-meeting-link.label': 'Share meeting',
+        'show-webrtc-stats.title': 'WebRTC Stats',
+        'show-calls-history.title': 'Service History',
 
-        'meeting summary label': 'Summary',
-        'summarize label': 'Summarize',
-        'summarizing label': 'Creating summary...',
-        'create summary message': 'A summary doesn’t exist for this meeting yet. Create one now?',
+        'meeting-summary.label': 'Summary',
+        'summarize.label': 'Summarize',
+        'summarizing.label': 'Creating summary...',
+        'create-summary.message': 'A summary doesn’t exist for this meeting yet. Create one now?',
 
-        'join call': 'Join',
-        'leave call': 'Leave',
+        'icon-pin.label': 'Pin video',
+        'icon-unpin.label': 'Unpin video',
+        'icon-wave.label': 'Waving',
+        'icon-muted.label': 'Muted',
+        'join-call.button': 'Join',
+        'leave-call.button': 'Leave',
+        'mic-on.button': 'Unmute',
+        'mic-off.button': 'Mute',
+        'camera-on.button': 'Turn camera on',
+        'camera-off.button': 'Turn camera off',
+        'camera-off.label': 'Camera off',
+        'raise-hand.button': 'Raise hand',
+        'lower-hand.button': 'Lower hand',
+        'screenshare-on.button': 'Share screen',
+        'screenshare-off.button': 'Stop streaming',
 
-        'lobby participants_zero': 'No participants',
-        'lobby participants_one': '1 participant',
-        'lobby participants_other': '{{count}} participants',
-
-        'icon pin': 'Pin video',
-        'icon unpin': 'Unpin video',
-        'icon wave': 'Waving',
-        'icon muted': 'Muted',
-        'icon speaking': 'Speaking',
-
-        'mic on': 'Unmute',
-        'mic off': 'Mute',
-        'camera on': 'Turn camera on',
-        'camera off': 'Turn camera off',
-        'camera off label': 'Camera off',
-
-        'raise hand': 'Raise hand',
-        'lower hand': 'Lower hand',
-        'screenshare on': 'Share screen',
-        'screenshare off': 'Stop streaming',
+        'channel-toolbar.title': 'Channel actions',
+        'start-video-call.menu': 'Start video call',
       },
     },
   },

package/src/types/ThreadCapabilities.ts

@@ -0,0 +1,47 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+// @import-as-namespace
+
+import * as Effect from 'effect/Effect';
+import type * as Schema from 'effect/Schema';
+
+import { Capability } from '@dxos/app-framework';
+import { type Obj } from '@dxos/echo';
+import { type Channel, type Message } from '@dxos/types';
+
+import { meta } from '#meta';
+
+/**
+ * A pluggable message backend for a `Channel`. Providers are contributed by
+ * plugins and resolved by `Channel.backend.kind`.
+ */
+export interface ChannelBackendProvider {
+  /** Stable backend id; matches `Channel.backend.kind`. */
+  kind: string;
+  /** Human-readable label shown in the create-channel form. */
+  label: string;
+  /** Icon name (phosphor) for the create-channel form. */
+  icon?: string;
+  /**
+   * Per-backend create-form inputs (a struct; excludes the `kind` discriminant
+   * and the channel `name`, which the panel adds). Empty struct when the backend
+   * needs no extra input (e.g. the local feed).
+   */
+  createFields: Schema.Schema.AnyNoContext;
+  /** Builds the provider's config object from the collected create-form inputs. */
+  makeConfig: (options: Record<string, unknown>) => Obj.Any;
+  /**
+   * Subscribes to the channel's messages. Invokes `onMessages` with the current
+   * list immediately and on every change. Returns an unsubscribe function.
+   */
+  subscribe: (channel: Channel.Channel, onMessages: (messages: readonly Message.Message[]) => void) => () => void;
+  /** Sends a message through the backend. */
+  send: (channel: Channel.Channel, message: Message.Message) => Effect.Effect<void, Error, Capability.Service>;
+  /** Whether the channel is read-only. Defaults to "channel has foreign-key Obj.Meta". */
+  readOnly?: (channel: Channel.Channel) => boolean;
+}
+
+/** Registry of channel-message backends. Collect with `Capability.getAll`. */
+export const ChannelBackend = Capability.make<ChannelBackendProvider>(`${meta.id}.capability.channel-backend`);

package/src/types/ThreadOperation.ts

@@ -0,0 +1,49 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+// @import-as-namespace
+
+import * as Schema from 'effect/Schema';
+
+import { Capability } from '@dxos/app-framework';
+import { Operation } from '@dxos/compute';
+import { Key, Type, DXN } from '@dxos/echo';
+import { Actor, Channel } from '@dxos/types';
+
+import { meta } from '#meta';
+
+const makeKey = (name: string) => DXN.make(`${meta.id}.operation.${name}`);
+
+export const CreateChannel = Operation.make({
+  meta: { key: makeKey('createChannel'), name: 'Create Channel', icon: 'ph--hash--regular' },
+  services: [Capability.Service],
+  input: Schema.Struct({
+    spaceId: Key.SpaceId,
+    name: Schema.optional(Schema.String),
+    /** Backend provider id; defaults to the local feed backend. */
+    kind: Schema.optional(Schema.String),
+    /** Per-backend create options passed to the provider's makeConfig. */
+    options: Schema.optional(Schema.Record({ key: Schema.String, value: Schema.Any })),
+  }),
+  output: Schema.Struct({
+    object: Type.getSchema(Channel.Channel),
+  }),
+});
+
+export const AppendChannelMessage = Operation.make({
+  meta: {
+    key: makeKey('appendChannelMessage'),
+    name: 'Append Channel Message',
+    icon: 'ph--chat-text--regular',
+  },
+  // Note: Feed.FeedService is provided inside the handler from space.queues, not at the
+  // operation level — the runtime can't fulfill it without a space context.
+  services: [Capability.Service],
+  input: Schema.Struct({
+    channel: Type.getSchema(Channel.Channel),
+    sender: Actor.Actor,
+    text: Schema.String,
+  }),
+  output: Schema.Void,
+});

package/src/types/channel-backend.test.ts

@@ -0,0 +1,48 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+import * as Schema from 'effect/Schema';
+import { describe, test } from 'vitest';
+
+import { Feed } from '@dxos/echo';
+
+import { buildChannelFormSchema, resolveProvider } from './channel-backend';
+import * as ThreadCapabilities from './ThreadCapabilities';
+
+describe('channel-backend helpers', () => {
+  test('resolveProvider finds by kind', ({ expect }) => {
+    const providers = [fakeProvider('a', Schema.Struct({})), fakeProvider('b', Schema.Struct({}))];
+    expect(resolveProvider(providers, 'b')?.kind).to.eq('b');
+    expect(resolveProvider(providers, 'missing')).to.be.undefined;
+  });
+
+  test('buildChannelFormSchema with a single empty-field provider is just a name field', ({ expect }) => {
+    const schema = buildChannelFormSchema([fakeProvider('feed', Schema.Struct({}))]);
+    const value = Schema.decodeUnknownSync(schema)({ name: 'general' });
+    expect(value.name).to.eq('general');
+    expect(value.backend).to.be.undefined;
+  });
+
+  test('buildChannelFormSchema with multiple providers builds a discriminated backend union', ({ expect }) => {
+    const schema = buildChannelFormSchema([
+      fakeProvider('feed', Schema.Struct({})),
+      fakeProvider('atproto', Schema.Struct({ channelId: Schema.String })),
+    ]);
+    const feedValue = Schema.decodeUnknownSync(schema)({ name: 'x', backend: { kind: 'feed' } });
+    expect(feedValue.backend.kind).to.eq('feed');
+    const atValue = Schema.decodeUnknownSync(schema)({ name: 'y', backend: { kind: 'atproto', channelId: 'c' } });
+    expect(atValue.backend.kind).to.eq('atproto');
+    expect(atValue.backend.channelId).to.eq('c');
+  });
+});
+
+const fakeProvider = (kind: string, fields: Schema.Schema.AnyNoContext): ThreadCapabilities.ChannelBackendProvider => ({
+  kind,
+  label: kind,
+  createFields: fields,
+  makeConfig: () => Feed.make(),
+  subscribe: () => () => {},
+  send: () => Effect.void,
+});

package/src/types/channel-backend.ts

@@ -0,0 +1,54 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Schema from 'effect/Schema';
+import * as SchemaAST from 'effect/SchemaAST';
+
+import * as ThreadCapabilities from './ThreadCapabilities';
+
+/** Finds the provider matching a `Channel.backend.kind`. */
+export const resolveProvider = (
+  providers: readonly ThreadCapabilities.ChannelBackendProvider[],
+  kind: string,
+): ThreadCapabilities.ChannelBackendProvider | undefined => providers.find((provider) => provider.kind === kind);
+
+/** Throws if two providers share a `kind` (which would make resolution order-dependent). */
+export const assertUniqueKinds = (providers: readonly ThreadCapabilities.ChannelBackendProvider[]): void => {
+  const seen = new Set<string>();
+  for (const provider of providers) {
+    if (seen.has(provider.kind)) {
+      throw new Error(`Duplicate channel backend kind: ${provider.kind}`);
+    }
+    seen.add(provider.kind);
+  }
+};
+
+/**
+ * Builds the create-channel form schema from the registered providers.
+ *
+ * With a single provider whose create-fields are empty the form is just a
+ * `name` field (today's behaviour). With multiple providers (or extra fields)
+ * it becomes `{ name?, backend: Union(<{ kind: Literal(p.kind) } & p.createFields>) }`,
+ * which react-ui-form renders as a `kind` Select plus the selected branch's fields.
+ */
+export const buildChannelFormSchema = (
+  providers: readonly ThreadCapabilities.ChannelBackendProvider[],
+): Schema.Schema.AnyNoContext => {
+  assertUniqueKinds(providers);
+  const needsSelector = providers.length > 1 || providers.some((provider) => fieldCount(provider.createFields) > 0);
+  if (!needsSelector) {
+    return Schema.Struct({ name: Schema.optional(Schema.String) });
+  }
+
+  const branches = providers.map((provider) =>
+    Schema.extend(Schema.Struct({ kind: Schema.Literal(provider.kind) }), provider.createFields),
+  );
+  const backend = branches.length === 1 ? branches[0] : Schema.Union(...branches);
+  return Schema.Struct({
+    name: Schema.optional(Schema.String),
+    backend,
+  });
+};
+
+const fieldCount = (schema: Schema.Schema.AnyNoContext): number => SchemaAST.getPropertySignatures(schema.ast).length;

package/src/types/index.ts

@@ -2,5 +2,6 @@
 // Copyright 2025 DXOS.org
 //
 
-export * from './schema';
-export * from './types';
+export * from './channel-backend';
+export * as ThreadCapabilities from './ThreadCapabilities';
+export * as ThreadOperation from './ThreadOperation';

package/src/util.ts

@@ -2,37 +2,54 @@
 // Copyright 2024 DXOS.org
 //
 
-import { Match } from 'effect';
-
 import { generateName } from '@dxos/display-name';
-import { type Selection } from '@dxos/plugin-attention';
-import { type PublicKey } from '@dxos/react-client';
 import { type Identity } from '@dxos/react-client/halo';
 import { type MessageMetadata } from '@dxos/react-ui-thread';
-import { hexToFallback } from '@dxos/util';
+import { hexToFallback, toFallback } from '@dxos/util';
 
-export type MessagePropertiesProvider = (identityKey: PublicKey | undefined) => MessageMetadata;
+/**
+ * Stable hash for an arbitrary string — used as the avatar-fallback seed for
+ * external senders who have no DXOS identity (e.g. Slack/Discord-synced
+ * messages). djb2-ish, only stability matters.
+ *
+ * Coerced to unsigned 32-bit via `>>> 0` because `toFallback` does a plain
+ * modulo against `idEmoji.length * idHue.length` and JavaScript's `%`
+ * preserves the sign of the dividend — a negative hash would index
+ * `idEmoji[-x]` and `idHue[-x]` to `undefined`, causing the avatar to fall
+ * through to `Avatar.Content`'s default red/ghost.
+ */
+const hashString = (s: string): number => {
+  let h = 0;
+  for (let i = 0; i < s.length; i++) {
+    h = (h * 31 + s.charCodeAt(i)) | 0;
+  }
+  return h >>> 0;
+};
 
-export const getMessageMetadata = (id: string, identity?: Identity): MessageMetadata => {
-  const fallback = hexToFallback(identity?.identityKey.toHex() ?? '0');
+export const getMessageMetadata = (
+  id: string,
+  identity?: Identity,
+  /**
+   * Externally-sourced sender info (Slack/Discord/etc). Used only when no
+   * matching DXOS `identity` is available — provides `name`/`email` for the
+   * author label and a stable seed for the avatar fallback.
+   */
+  fallbackSender?: { name?: string; email?: string },
+): MessageMetadata => {
+  const fallback = identity?.identityKey
+    ? hexToFallback(identity.identityKey.toHex())
+    : toFallback(hashString(fallbackSender?.name ?? fallbackSender?.email ?? '0'));
   return {
     id,
     authorId: identity?.did,
     authorName:
       identity?.profile?.displayName ??
-      (identity?.identityKey ? generateName(identity.identityKey.toHex()) : undefined),
+      (identity?.identityKey ? generateName(identity.identityKey.toHex()) : undefined) ??
+      fallbackSender?.name ??
+      fallbackSender?.email,
     authorAvatarProps: {
       hue: identity?.profile?.data?.hue ?? fallback.hue,
       emoji: identity?.profile?.data?.emoji ?? fallback.emoji,
     },
   };
 };
-
-export const getAnchor = Match.type<Selection | undefined>().pipe(
-  Match.when({ mode: 'single' }, (s) => s.id),
-  Match.when({ mode: 'multi' }, (s) => (s.ids.length > 0 ? s.ids.join(',') : undefined)),
-  Match.when({ mode: 'range' }, (s) => (s.from && s.to ? `${s.from}:${s.to}` : undefined)),
-  Match.when({ mode: 'multi-range' }, (s) => s.ranges[0] && `${s.ranges[0].from}:${s.ranges[0].to}`),
-  Match.when(undefined, () => undefined),
-  Match.exhaustive,
-);

package/src/vite-env.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="vite/client" />
+
+//
+// Copyright 2026 DXOS.org
+//
+
+declare module '*.mdl?raw' {
+  const content: string;
+  export default content;
+}

package/dist/lib/browser/ChannelContainer-O2SFQJU7.mjs

@@ -1,16 +0,0 @@
-import {
-  ChannelContainer,
-  ChannelContainer_default
-} from "./chunk-ZJ7QBXK6.mjs";
-import "./chunk-2CWJBXBH.mjs";
-import "./chunk-4APCDRSH.mjs";
-import "./chunk-J3JO5NWO.mjs";
-import "./chunk-X5PIP5YR.mjs";
-import "./chunk-GERVMFQW.mjs";
-import "./chunk-JGKMMI65.mjs";
-import "./chunk-EV4JWI7L.mjs";
-export {
-  ChannelContainer,
-  ChannelContainer_default as default
-};
-//# sourceMappingURL=ChannelContainer-O2SFQJU7.mjs.map

package/dist/lib/browser/ChatContainer-PVT3DUZJ.mjs

@@ -1,15 +0,0 @@
-import {
-  ChatContainer,
-  ChatContainer_default,
-  ChatHeading
-} from "./chunk-J3JO5NWO.mjs";
-import "./chunk-X5PIP5YR.mjs";
-import "./chunk-GERVMFQW.mjs";
-import "./chunk-JGKMMI65.mjs";
-import "./chunk-EV4JWI7L.mjs";
-export {
-  ChatContainer,
-  ChatHeading,
-  ChatContainer_default as default
-};
-//# sourceMappingURL=ChatContainer-PVT3DUZJ.mjs.map