@dxos/plugin-registry 0.8.4-main.9be5663bfe → 0.8.4-main.abd8ff62ef

package/src/components/PluginList/PluginItem.tsx

@@ -2,10 +2,21 @@
 // Copyright 2025 DXOS.org
 //
 
-import React, { type MouseEvent, useCallback } from 'react';
+import React, { type MouseEvent, useCallback, useMemo } from 'react';
 
 import { type Plugin } from '@dxos/app-framework';
-import { type ChromaticPalette, Icon, IconButton, Input, Link, ListItem, Tag, useTranslation } from '@dxos/react-ui';
+import {
+  Button,
+  type ChromaticPalette,
+  Icon,
+  IconButton,
+  Input,
+  Link,
+  ListItem,
+  type NeutralPalette,
+  Tag,
+  useTranslation,
+} from '@dxos/react-ui';
 import { mx } from '@dxos/ui-theme';
 import { getStyles } from '@dxos/ui-theme';
 
@@ -14,25 +25,55 @@ import { type RegistryTagType } from '#types';
 
 export type PluginItemProps = {
   plugin: Plugin.Plugin;
+  /** Ids of plugins currently installed (loaded into the manager). */
   installed?: readonly string[];
+  /** Ids of plugins whose install is in flight. */
+  installing?: readonly string[];
   enabled?: readonly string[];
+  /**
+   * Derived tags (e.g. `community`, `local`) to display alongside the plugin's own meta.tags.
+   * Not persisted to plugin meta; computed per-render by the container.
+   */
+  extraTags?: readonly string[];
   onClick?: (id: string) => void;
   onChange?: (id: string, enabled: boolean) => void;
+  /**
+   * Install handler. When provided and the plugin is not installed, an Install button
+   * is rendered in place of the enable switch.
+   */
+  onInstall?: (id: string) => void;
   hasSettings?: (id: string) => boolean;
   onSettings?: (id: string) => void;
 };
 
 export const PluginItem = ({
   plugin,
+  installed,
+  installing,
   enabled = [],
+  extraTags,
   onClick,
   onChange,
+  onInstall,
   hasSettings: hasSettingsProp,
   onSettings,
 }: PluginItemProps) => {
   const { t } = useTranslation(meta.id);
   const { id, name, description, tags, icon = 'ph--circle--regular', iconHue = 'neutral' } = plugin.meta;
+  const displayTags = useMemo(() => {
+    if (!extraTags || extraTags.length === 0) {
+      return tags ?? [];
+    }
+    const set = new Set<string>(tags ?? []);
+    for (const tag of extraTags) {
+      set.add(tag);
+    }
+    return Array.from(set);
+  }, [tags, extraTags]);
   const isEnabled = enabled.includes(id);
+  const isInstalled = installed ? installed.includes(id) : true;
+  const isInstalling = installing?.includes(id) ?? false;
+  const showInstallButton = !!onInstall && !isInstalled;
   const inputId = `${id}-input`;
   const labelId = `${id}-label`;
   const descriptionId = `${id}-description`;
@@ -46,6 +87,14 @@ export const PluginItem = ({
     [id, isEnabled, onChange],
   );
 
+  const handleInstall = useCallback(
+    (event: MouseEvent) => {
+      event.stopPropagation();
+      onInstall?.(id);
+    },
+    [id, onInstall],
+  );
+
   const hasSettings = hasSettingsProp?.(id) ?? false;
   const handleSettings = useCallback(() => onSettings?.(id), [id, onSettings]);
   const styles = getStyles(iconHue);
@@ -79,7 +128,7 @@ export const PluginItem = ({
         </div>
 
         <div className='flex -ms-0.5 overflow-x-auto scrollbar-none'>
-          {tags?.map((tag) => (
+          {displayTags.map((tag) => (
             <Tag key={tag} palette={tagColors[tag as RegistryTagType]} classNames='text-xs uppercase font-thin'>
               {tag}
             </Tag>
@@ -91,7 +140,7 @@ export const PluginItem = ({
             aria-describedby={descriptionId}
             classNames='cursor-pointer'
             icon='ph--gear--regular'
-            label={t('settings.label')}
+            label={t('plugin-settings.label')}
             iconOnly
             size={4}
             onClick={handleSettings}
@@ -104,9 +153,21 @@ export const PluginItem = ({
 
           <div className='grow' />
           <div className='pe-1'>
-            <Input.Root id={inputId}>
-              <Input.Switch classNames='self-center' checked={isEnabled} onClick={handleChange} />
-            </Input.Root>
+            {showInstallButton ? (
+              <Button
+                aria-describedby={descriptionId}
+                density='fine'
+                variant='primary'
+                disabled={isInstalling}
+                onClick={handleInstall}
+              >
+                {isInstalling ? t('installing.label') : t('install.label')}
+              </Button>
+            ) : (
+              <Input.Root id={inputId}>
+                <Input.Switch classNames='self-center' checked={isEnabled} onClick={handleChange} />
+              </Input.Root>
+            )}
           </div>
         </div>
       </div>
@@ -114,11 +175,13 @@ export const PluginItem = ({
   );
 };
 
-const tagColors: Record<RegistryTagType, ChromaticPalette> = {
+const tagColors: Record<RegistryTagType, ChromaticPalette | NeutralPalette> = {
   new: 'rose',
   beta: 'teal',
   labs: 'blue',
   popular: 'green',
   featured: 'pink',
   experimental: 'amber',
+  community: 'indigo',
+  local: 'neutral',
 };

package/src/components/PluginList/PluginList.stories.tsx

@@ -11,9 +11,9 @@ import { ScrollArea } from '@dxos/react-ui';
 import { withLayout, withTheme } from '@dxos/react-ui/testing';
 import { getHashHue } from '@dxos/ui-theme';
 
+import { translations } from '#translations';
 import { RegistryTagType } from '#types';
 
-import { translations } from '../../translations';
 import { PluginList } from './PluginList';
 
 random.seed(1);

package/src/components/PluginList/PluginList.tsx

@@ -9,15 +9,20 @@ import { List } from '@dxos/react-ui';
 
 import { PluginItem, type PluginItemProps } from './PluginItem';
 
-export type PluginListProps = Omit<PluginItemProps, 'plugin'> & {
+export type PluginListProps = Omit<PluginItemProps, 'plugin' | 'extraTags'> & {
   plugins?: readonly Plugin.Plugin[];
+  /**
+   * Map from plugin id → extra tags to display (e.g. `community`, `local`).
+   * Computed by the container; not persisted to plugin meta.
+   */
+  extraTagsById?: Record<string, readonly string[]>;
 };
 
-export const PluginList = ({ plugins = [], ...props }: PluginListProps) => {
+export const PluginList = ({ plugins = [], extraTagsById, ...props }: PluginListProps) => {
   return (
     <List classNames='grid grid-cols-[repeat(auto-fill,minmax(18rem,1fr))] auto-rows-[max-content] gap-4 p-4'>
       {plugins.map((plugin) => (
-        <PluginItem key={plugin.meta.id} plugin={plugin} {...props} />
+        <PluginItem key={plugin.meta.id} plugin={plugin} extraTags={extraTagsById?.[plugin.meta.id]} {...props} />
       ))}
     </List>
   );

package/src/containers/CommunityRegistry/CommunityRegistry.tsx

@@ -0,0 +1,181 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { useAtomValue } from '@effect-atom/atom-react';
+import * as Effect from 'effect/Effect';
+import React, { useCallback, useMemo, useState } from 'react';
+
+import { Plugin, UrlLoader } from '@dxos/app-framework';
+import { useCapabilities, useOperationInvoker, usePluginManager } from '@dxos/app-framework/ui';
+import { AppCapabilities, LayoutOperation, SettingsOperation } from '@dxos/app-toolkit';
+import { runAndForwardErrors } from '@dxos/effect';
+import { ObservabilityOperation } from '@dxos/plugin-observability/operations';
+import { type PluginEntry } from '@dxos/protocols';
+import { ScrollArea, useTranslation } from '@dxos/react-ui';
+import { composable, composableProps } from '@dxos/ui-theme';
+
+import { PluginList } from '#components';
+import { getPluginPath, meta } from '#meta';
+
+import { useAutoTags, useCommunityPlugins } from '../../hooks';
+
+const sortEntries = (a: PluginEntry, b: PluginEntry) =>
+  (a.meta.name ?? a.meta.id).localeCompare(b.meta.name ?? b.meta.id);
+
+const sortPlugins = (a: Plugin.Plugin, b: Plugin.Plugin) =>
+  (a.meta.name ?? a.meta.id).localeCompare(b.meta.name ?? b.meta.id);
+
+/**
+ * Turns a community manifest entry into a minimal Plugin object so we can reuse
+ * {@link PluginList} for rendering. The synthesized plugin has no modules — it
+ * exists only for display until the user installs it.
+ */
+const toDisplayPlugin = (entry: PluginEntry): Plugin.Plugin =>
+  ({
+    [Plugin.PluginTypeId]: Plugin.PluginTypeId,
+    meta: entry.meta,
+    modules: [],
+  }) as Plugin.Plugin;
+
+export type CommunityRegistryProps = {
+  id: string;
+};
+
+export const CommunityRegistry = composable<HTMLDivElement, CommunityRegistryProps>(
+  ({ id, ...props }, forwardedRef) => {
+    const { t } = useTranslation(meta.id);
+    const manager = usePluginManager();
+    const { invoke, invokePromise } = useOperationInvoker();
+    const { entries, loading, error } = useCommunityPlugins();
+    const enabled = useAtomValue(manager.enabled);
+    const plugins = useAtomValue(manager.plugins);
+    const installedIds = useMemo(() => plugins.map((plugin) => plugin.meta.id), [plugins]);
+    const allSettings = useCapabilities(AppCapabilities.Settings);
+    const extraTagsById = useAutoTags(entries);
+
+    // Snapshot of installed plugin ids at mount time. Used to sort installed
+    // plugins to the top without having newly-installed rows jump up mid-session.
+    const [installedSnapshot] = useState<ReadonlySet<string>>(
+      () => new Set(manager.getPlugins().map((plugin) => plugin.meta.id)),
+    );
+
+    const [installingIds, setInstallingIds] = useState<readonly string[]>([]);
+
+    const sortedEntries = useMemo(() => [...entries].sort(sortEntries), [entries]);
+    const moduleUrlById = useMemo(() => {
+      const map: Record<string, string> = {};
+      for (const entry of sortedEntries) {
+        map[entry.meta.id] = entry.moduleUrl;
+      }
+      return map;
+    }, [sortedEntries]);
+
+    // Single list with installed-at-mount plugins sorted to the top. Sort order
+    // is based on the mount-time snapshot so rows don't jump as the user
+    // installs plugins during the session.
+    const items = useMemo(() => {
+      const catalogIds = new Set(sortedEntries.map((entry) => entry.meta.id));
+      const remoteIds = new Set(UrlLoader.getRemoteEntries().map((entry) => entry.id));
+      const fromCatalog = sortedEntries.map(toDisplayPlugin);
+      const fromUrlOnly = plugins.filter((plugin) => remoteIds.has(plugin.meta.id) && !catalogIds.has(plugin.meta.id));
+      const installedFirst = [...fromCatalog, ...fromUrlOnly].sort((a, b) => {
+        const aInstalled = installedSnapshot.has(a.meta.id);
+        const bInstalled = installedSnapshot.has(b.meta.id);
+        if (aInstalled !== bInstalled) {
+          return aInstalled ? -1 : 1;
+        }
+        return sortPlugins(a, b);
+      });
+      return installedFirst;
+    }, [sortedEntries, installedSnapshot, plugins]);
+
+    const handleChange = useCallback(
+      (pluginId: string, nextEnabled: boolean) =>
+        Effect.gen(function* () {
+          if (nextEnabled) {
+            yield* manager.enable(pluginId);
+          } else {
+            yield* manager.disable(pluginId);
+          }
+
+          yield* invoke(ObservabilityOperation.SendEvent, {
+            name: 'plugins.toggle',
+            properties: { plugin: pluginId, enabled: nextEnabled, source: 'community' },
+          });
+        }).pipe(runAndForwardErrors),
+      [invoke, manager],
+    );
+
+    const handleInstall = useCallback(
+      (pluginId: string) => {
+        const moduleUrl = moduleUrlById[pluginId];
+        if (!moduleUrl) {
+          return;
+        }
+        setInstallingIds((prev) => (prev.includes(pluginId) ? prev : [...prev, pluginId]));
+        void void Effect.gen(function* () {
+          const plugin = yield* manager.add(moduleUrl);
+          yield* manager.enable(plugin.meta.id);
+          yield* invoke(ObservabilityOperation.SendEvent, {
+            name: 'plugins.install',
+            properties: { plugin: plugin.meta.id, source: 'community' },
+          });
+        }).pipe(
+          Effect.ensuring(Effect.sync(() => setInstallingIds((prev) => prev.filter((pid) => pid !== pluginId)))),
+          runAndForwardErrors,
+        );
+      },
+      [invoke, manager, moduleUrlById],
+    );
+
+    const handleClick = useCallback(
+      (pluginId: string) =>
+        invokePromise(LayoutOperation.Open, {
+          subject: [getPluginPath(pluginId)],
+          pivotId: id,
+          positioning: 'end',
+        }),
+      [invokePromise, id],
+    );
+
+    const hasSettings = useCallback(
+      (pluginId: string) => allSettings.some((setting) => setting.prefix === pluginId),
+      [allSettings],
+    );
+
+    const handleSettings = useCallback(
+      (pluginId: string) => invokePromise(SettingsOperation.Open, { plugin: pluginId }),
+      [invokePromise],
+    );
+
+    return (
+      <ScrollArea.Root {...composableProps(props)} orientation='vertical' ref={forwardedRef}>
+        <ScrollArea.Viewport>
+          {items.length > 0 ? (
+            <PluginList
+              plugins={items}
+              installed={installedIds}
+              installing={installingIds}
+              enabled={enabled}
+              extraTagsById={extraTagsById}
+              onClick={handleClick}
+              onChange={handleChange}
+              onInstall={handleInstall}
+              hasSettings={hasSettings}
+              onSettings={handleSettings}
+            />
+          ) : error ? (
+            <div className='p-4 text-description'>Failed to load community plugins: {error.message}</div>
+          ) : loading ? (
+            <div className='p-4 text-description'>{t('loading.label')}</div>
+          ) : (
+            <div className='p-4 text-description'>No community plugins available.</div>
+          )}
+        </ScrollArea.Viewport>
+      </ScrollArea.Root>
+    );
+  },
+);
+
+CommunityRegistry.displayName = 'CommunityRegistry';

package/src/containers/CommunityRegistry/index.ts

@@ -0,0 +1,5 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+export { CommunityRegistry as default, CommunityRegistry } from './CommunityRegistry';

package/src/containers/LoadPluginDialog/LoadPluginDialog.tsx

@@ -30,7 +30,8 @@ export const LoadPluginDialog = () => {
     setError(null);
 
     void Effect.gen(function* () {
-      yield* manager.add(url.trim());
+      const plugin = yield* manager.add(url.trim());
+      yield* manager.enable(plugin.meta.id);
       closeRef.current?.click();
     }).pipe(
       Effect.catchAll((err) =>

package/src/containers/PluginArticle/PluginArticle.tsx

@@ -2,7 +2,9 @@
 // Copyright 2025 DXOS.org
 //
 
-import React, { useCallback } from 'react';
+import { useAtomValue } from '@effect-atom/atom-react';
+import * as Effect from 'effect/Effect';
+import React, { useCallback, useMemo, useState } from 'react';
 
 import { type Plugin } from '@dxos/app-framework';
 import { usePluginManager } from '@dxos/app-framework/ui';
@@ -10,12 +12,31 @@ import { runAndForwardErrors } from '@dxos/effect';
 
 import { PluginDetail } from '#components';
 
+import { useCommunityPlugins, useRemotePluginIds } from '../../hooks';
+
 // TODO(burdon): Convert to ECHO type.
 export type PluginArticleProps = { subject: Plugin.Plugin };
 
 export const PluginArticle = ({ subject: plugin }: PluginArticleProps) => {
   const manager = usePluginManager();
+  const plugins = useAtomValue(manager.plugins);
+  const { entries } = useCommunityPlugins();
+  const remotePluginIds = useRemotePluginIds();
+  const [installing, setInstalling] = useState(false);
+
   const enabled = manager.getEnabled().includes(plugin.meta.id);
+  const isInstalled = useMemo(
+    () => plugins.some((candidate) => candidate.meta.id === plugin.meta.id),
+    [plugins, plugin.meta.id],
+  );
+  const isCore = manager.getCore().includes(plugin.meta.id);
+  const canUninstall = isInstalled && !isCore && remotePluginIds.has(plugin.meta.id);
+
+  const moduleUrl = useMemo(
+    () => entries.find((entry) => entry.meta.id === plugin.meta.id)?.moduleUrl,
+    [entries, plugin.meta.id],
+  );
+
   const handleEnableChange = useCallback(
     (enabled: boolean) =>
       enabled
@@ -24,5 +45,29 @@ export const PluginArticle = ({ subject: plugin }: PluginArticleProps) => {
     [manager, plugin.meta.id],
   );
 
-  return <PluginDetail plugin={plugin} enabled={enabled} onEnabledChange={handleEnableChange} />;
+  const handleUninstall = useCallback(() => {
+    void runAndForwardErrors(manager.remove(plugin.meta.id));
+  }, [manager, plugin.meta.id]);
+
+  const handleInstall = useCallback(() => {
+    if (!moduleUrl) {
+      return;
+    }
+    setInstalling(true);
+    void Effect.gen(function* () {
+      const added = yield* manager.add(moduleUrl);
+      yield* manager.enable(added.meta.id);
+    }).pipe(Effect.ensuring(Effect.sync(() => setInstalling(false))), runAndForwardErrors);
+  }, [manager, moduleUrl]);
+
+  return (
+    <PluginDetail
+      plugin={plugin}
+      enabled={enabled}
+      onEnabledChange={handleEnableChange}
+      onInstall={!isInstalled && moduleUrl ? handleInstall : undefined}
+      installing={installing}
+      onUninstall={canUninstall ? handleUninstall : undefined}
+    />
+  );
 };

package/src/containers/PluginRegistry/PluginRegistry.tsx

@@ -23,17 +23,20 @@ const sortByPluginMeta = ({ meta: { name: a = '' } }: Plugin.Plugin, { meta: { n
 export type PluginRegistryProps = {
   id: string;
   plugins: Plugin.Plugin[];
+  /**
+   * Map from plugin id → display-only tags (e.g. `community`, `local`) computed by the caller.
+   */
+  extraTagsById?: Record<string, readonly string[]>;
 };
 
 export const PluginRegistry = composable<HTMLDivElement, PluginRegistryProps>(
-  ({ id, plugins: pluginsProp, ...props }, forwardedRef) => {
+  ({ id, plugins: pluginsProp, extraTagsById, ...props }, forwardedRef) => {
     const manager = usePluginManager();
     const { invoke, invokePromise } = useOperationInvoker();
     const plugins = useMemo(() => pluginsProp.sort(sortByPluginMeta), [pluginsProp]);
     const enabled = useAtomValue(manager.enabled);
     const allSettings = useCapabilities(AppCapabilities.Settings);
 
-    // TODO(wittjosiah): Factor out to an intent?
     const handleChange = useCallback(
       (id: string, enabled: boolean) =>
         Effect.gen(function* () {
@@ -80,6 +83,7 @@ export const PluginRegistry = composable<HTMLDivElement, PluginRegistryProps>(
           <PluginList
             plugins={plugins}
             enabled={enabled}
+            extraTagsById={extraTagsById}
             onClick={handleClick}
             onChange={handleChange}
             hasSettings={hasSettings}

package/src/containers/index.ts

@@ -5,6 +5,7 @@
 import { type ComponentType, lazy } from 'react';
 
 export { LOAD_PLUGIN_DIALOG } from './LoadPluginDialog/LoadPluginDialog';
+export const CommunityRegistry: ComponentType<any> = lazy(() => import('./CommunityRegistry'));
 export const LoadPluginDialog: ComponentType<any> = lazy(() => import('./LoadPluginDialog'));
 export const PluginArticle: ComponentType<any> = lazy(() => import('./PluginArticle'));
 export const PluginRegistry: ComponentType<any> = lazy(() => import('./PluginRegistry'));

package/src/hooks/index.ts

@@ -0,0 +1,6 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+export * from './use-auto-tags';
+export * from './use-community-plugins';

package/src/hooks/use-auto-tags.ts

@@ -0,0 +1,52 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { useMemo } from 'react';
+
+import { UrlLoader } from '@dxos/app-framework';
+import { type PluginEntry } from '@dxos/protocols';
+
+/**
+ * Auto-tags that are derived at display time rather than persisted to `Plugin.Meta`.
+ * - `community`: plugin id appears in the community registry manifest.
+ * - `local`: plugin was loaded from a `localhost` / `127.0.0.1` / `::1` URL.
+ */
+export type AutoTagsMap = Record<string, readonly string[]>;
+
+/**
+ * Computes the per-plugin-id extra tags the UI should display.
+ *
+ * Reads the persisted remote-plugin entries synchronously to derive `local`, and
+ * adds `community` for any plugin id found in the supplied community manifest entries.
+ */
+export const useAutoTags = (communityEntries: readonly PluginEntry[]): AutoTagsMap =>
+  useMemo(() => {
+    const byId: Record<string, string[]> = {};
+    const addTag = (id: string, tag: string) => {
+      const existing = byId[id];
+      if (!existing) {
+        byId[id] = [tag];
+      } else if (!existing.includes(tag)) {
+        existing.push(tag);
+      }
+    };
+
+    for (const entry of UrlLoader.getRemoteEntries()) {
+      if (UrlLoader.isLocalUrl(entry.url)) {
+        addTag(entry.id, 'local');
+      }
+    }
+    for (const entry of communityEntries) {
+      addTag(entry.meta.id, 'community');
+    }
+
+    return byId;
+  }, [communityEntries]);
+
+/**
+ * Returns the set of plugin ids known to originate from a remote URL (not bundled).
+ * Used to filter the Official/Recommended sections so third-party plugins are excluded.
+ */
+export const useRemotePluginIds = (): ReadonlySet<string> =>
+  useMemo(() => new Set(UrlLoader.getRemoteEntries().map((entry) => entry.id)), []);

package/src/hooks/use-community-plugins.ts

@@ -0,0 +1,35 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { Atom, useAtomValue } from '@effect-atom/atom-react';
+import * as Effect from 'effect/Effect';
+
+import { useCapabilities } from '@dxos/app-framework/ui';
+import { Context } from '@dxos/context';
+import { type EdgeHttpClient } from '@dxos/edge-client';
+import { type PluginEntry } from '@dxos/protocols';
+
+import { RegistryCapabilities, type CommunityPluginsState } from '#types';
+
+/**
+ * Fetches the community plugin catalog from the Edge registry service and
+ * filters out unhealthy entries.
+ */
+export const loadCommunityPlugins = (client: EdgeHttpClient): Effect.Effect<readonly PluginEntry[], Error> =>
+  Effect.tryPromise({
+    try: () => client.getRegistryPlugins(Context.default()),
+    catch: (error) => (error instanceof Error ? error : new Error(String(error))),
+  }).pipe(Effect.map((body) => body.plugins.filter((entry) => entry.health === 'ok')));
+
+const emptyAtom = Atom.make<CommunityPluginsState>({ entries: [], loading: true, error: null });
+
+/**
+ * Reads the community plugin catalog from the registry state capability. The
+ * catalog is loaded once at plugin startup so this hook is purely reactive.
+ * Returns the empty/loading state until the state capability activates.
+ */
+export const useCommunityPlugins = (): CommunityPluginsState => {
+  const atoms = useCapabilities(RegistryCapabilities.State);
+  return useAtomValue(atoms[0] ?? emptyAtom);
+};

package/src/index.ts

@@ -2,5 +2,9 @@
 // Copyright 2023 DXOS.org
 //
 
+import { Plugin } from '@dxos/app-framework';
+
+import { meta } from './meta';
+
 export * from './meta';
-export * from './RegistryPlugin';
+export const RegistryPlugin = Plugin.lazy(meta, () => import('#plugin'));

package/src/operations/index.ts

@@ -2,6 +2,6 @@
 // Copyright 2025 DXOS.org
 //
 
-import { OperationHandlerSet } from '@dxos/operation';
+import { OperationHandlerSet } from '@dxos/compute';
 
 export const RegistryOperationHandlerSet = OperationHandlerSet.lazy(() => import('./open-plugin-registry'));

package/src/operations/open-plugin-registry.ts

@@ -5,7 +5,7 @@
 import * as Effect from 'effect/Effect';
 
 import { LayoutOperation, SettingsOperation, getSpacePath } from '@dxos/app-toolkit';
-import { Operation } from '@dxos/operation';
+import { Operation } from '@dxos/compute';
 
 import { REGISTRY_ID } from '#meta';
 

package/src/translations.ts

@@ -15,7 +15,8 @@ export const translations = [
         'home-page.label': 'Website',
         'source.label': 'Source',
         'plugin-registry.label': 'Plugin Registry',
-        'all-plugins.label': 'All',
+        'plugin-settings.label': 'Plugin Settings',
+        'official-plugins.label': 'Official',
         'installed-plugins.label': 'Enabled',
         'recommended-plugins.label': 'Recommended',
         'labs-plugins.label': 'Labs',
@@ -27,7 +28,9 @@ export const translations = [
         'loading.label': 'Loading...',
         'coming-soon.label': 'Coming soon!',
         'open-plugin-registry.label': 'Open plugin registry',
-        'settings.label': 'Settings',
+        'install.label': 'Install',
+        'installing.label': 'Installing…',
+        'uninstall.label': 'Uninstall',
       },
     },
   },