@dxos/plugin-registry 0.8.4-main.dedc0f3 → 0.8.4-main.dfabb4ec29

package/src/containers/PublicRegistryArticle/PublicRegistryArticle.tsx

@@ -0,0 +1,192 @@
+//
+// 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 { type Registry, Plugin, UrlLoader } from '@dxos/app-framework';
+import { useOperationInvoker, usePluginManager } from '@dxos/app-framework/ui';
+import { runAndForwardErrors } from '@dxos/effect';
+import { ObservabilityOperation } from '@dxos/plugin-observability';
+import { useTranslation } from '@dxos/react-ui';
+import { composable } from '@dxos/ui-theme';
+
+import { meta } from '#meta';
+
+import { useAutoTags, useRegistryPlugins, useUpdateAvailableIds } from '../../hooks';
+import { BaseRegistryArticle } from '../BaseRegistryArticle';
+
+const sortEntries = (a: Registry.Plugin, b: Registry.Plugin) => (a.name ?? a.id).localeCompare(b.name ?? b.id);
+
+const sortPlugins = (a: Plugin.Plugin, b: Plugin.Plugin) =>
+  (a.meta.name ?? a.meta.id).localeCompare(b.meta.name ?? b.meta.id);
+
+/**
+ * Turns a registry catalog entry into a minimal Plugin object so we can reuse
+ * {@link BaseRegistryArticle} for rendering. The synthesized plugin has no
+ * modules — it exists only for display until the user installs it.
+ */
+const toDisplayPlugin = (plugin: Registry.Plugin): Plugin.Plugin =>
+  ({
+    [Plugin.PluginTypeId]: Plugin.PluginTypeId,
+    meta: {
+      id: plugin.id,
+      name: plugin.name,
+      description: plugin.description,
+      homePage: plugin.homePage,
+      source: plugin.source,
+      screenshots: plugin.screenshots,
+      tags: plugin.tags,
+      icon: plugin.icon,
+      iconHue: plugin.iconHue,
+    },
+    modules: [],
+  }) as Plugin.Plugin;
+
+export type PublicRegistryArticleProps = {
+  id: string;
+};
+
+export const PublicRegistryArticle = composable<HTMLDivElement, PublicRegistryArticleProps>(
+  ({ id, ...props }, forwardedRef) => {
+    const { t } = useTranslation(meta.id);
+    const manager = usePluginManager();
+    const { invoke } = useOperationInvoker();
+    const { entries, loading, error } = useRegistryPlugins();
+    const plugins = useAtomValue(manager.plugins);
+    const installedIds = useMemo(() => plugins.map((plugin) => plugin.meta.id), [plugins]);
+    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 [updatingIds, setUpdatingIds] = useState<readonly string[]>([]);
+    const updateAvailableIds = useUpdateAvailableIds(entries);
+
+    const sortedEntries = useMemo(() => [...entries].sort(sortEntries), [entries]);
+    const moduleUrlById = useMemo(() => {
+      const map: Record<string, string> = {};
+      for (const entry of sortedEntries) {
+        map[entry.id] = entry.moduleUrl;
+      }
+      return map;
+    }, [sortedEntries]);
+
+    // Maps plugin id → current registry version (i.e. plugin.version from the catalog).
+    const versionById = useMemo(() => {
+      const map: Record<string, string> = {};
+      for (const entry of sortedEntries) {
+        map[entry.id] = entry.version;
+      }
+      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.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 handleInstall = useCallback(
+      (pluginId: string) => {
+        const moduleUrl = moduleUrlById[pluginId];
+        const version = versionById[pluginId];
+        if (!moduleUrl) {
+          return;
+        }
+        setInstallingIds((prev) => (prev.includes(pluginId) ? prev : [...prev, pluginId]));
+        void Effect.gen(function* () {
+          const plugin = yield* manager.add(moduleUrl);
+          yield* manager.enable(plugin.meta.id);
+          // Persist the installed version for future update detection.
+          if (version) {
+            UrlLoader.setInstalledVersion(plugin.meta.id, version);
+          }
+          yield* invoke(ObservabilityOperation.SendEvent, {
+            name: 'plugins.install',
+            properties: { plugin: plugin.meta.id, source: 'registry' },
+          });
+        }).pipe(
+          Effect.ensuring(Effect.sync(() => setInstallingIds((prev) => prev.filter((pid) => pid !== pluginId)))),
+          runAndForwardErrors,
+        );
+      },
+      [invoke, manager, moduleUrlById, versionById],
+    );
+
+    const handleUpdate = useCallback(
+      (pluginId: string) => {
+        const moduleUrl = moduleUrlById[pluginId];
+        const version = versionById[pluginId];
+        if (!moduleUrl) {
+          return;
+        }
+        setUpdatingIds((prev) => (prev.includes(pluginId) ? prev : [...prev, pluginId]));
+        void Effect.gen(function* () {
+          // Unload the old version then re-install from the new URL.
+          yield* manager.remove(pluginId);
+          const plugin = yield* manager.add(moduleUrl);
+          yield* manager.enable(plugin.meta.id);
+          if (version) {
+            UrlLoader.setInstalledVersion(plugin.meta.id, version);
+          }
+          yield* invoke(ObservabilityOperation.SendEvent, {
+            name: 'plugins.update',
+            properties: { plugin: plugin.meta.id, source: 'registry' },
+          });
+        }).pipe(
+          Effect.ensuring(Effect.sync(() => setUpdatingIds((prev) => prev.filter((pid) => pid !== pluginId)))),
+          runAndForwardErrors,
+        );
+      },
+      [invoke, manager, moduleUrlById, versionById],
+    );
+
+    const empty = error ? (
+      <div className='p-4 text-description'>{t('registry.error.label', { message: error.message })}</div>
+    ) : loading ? (
+      <div className='p-4 text-description'>{t('registry.loading.label')}</div>
+    ) : (
+      <div className='p-4 text-description'>{t('registry.empty.label')}</div>
+    );
+
+    return (
+      <BaseRegistryArticle
+        {...props}
+        id={id}
+        source='registry'
+        plugins={items}
+        installed={installedIds}
+        installing={installingIds}
+        updating={updatingIds}
+        updateAvailableIds={updateAvailableIds}
+        extraTagsById={extraTagsById}
+        onInstall={handleInstall}
+        onUpdate={handleUpdate}
+        empty={empty}
+        ref={forwardedRef}
+      />
+    );
+  },
+);
+
+PublicRegistryArticle.displayName = 'PublicRegistryArticle';

package/src/containers/PublicRegistryArticle/index.ts

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

package/src/containers/RegistryArticle/RegistryArticle.tsx

@@ -0,0 +1,53 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import { useAtomValue } from '@effect-atom/atom-react';
+import React, { useMemo } from 'react';
+
+import { type Plugin, type PluginManager } from '@dxos/app-framework';
+import { usePluginManager } from '@dxos/app-framework/ui';
+import { composable } from '@dxos/ui-theme';
+
+import { BaseRegistryArticle } from '../BaseRegistryArticle';
+
+const sortByPluginMeta = (a: Plugin.Plugin, b: Plugin.Plugin) =>
+  (a.meta.name ?? a.meta.id).localeCompare(b.meta.name ?? b.meta.id);
+
+export type RegistryArticleProps = {
+  id: string;
+  plugins: Plugin.Plugin[];
+  /**
+   * Map from plugin id → display-only tags (e.g. `registry`, `local`) computed by the caller.
+   */
+  extraTagsById?: Record<string, readonly string[]>;
+};
+
+export const RegistryArticle = composable<HTMLDivElement, RegistryArticleProps>(
+  ({ id, plugins: pluginsProp, extraTagsById, ...props }, forwardedRef) => {
+    const manager = usePluginManager();
+    const failed = useAtomValue(manager.failed);
+    const plugins = useMemo(() => [...pluginsProp].sort(sortByPluginMeta), [pluginsProp]);
+    const failuresById = useMemo(
+      () =>
+        failed.reduce<Record<string, PluginManager.PluginFailure>>((acc, failure) => {
+          acc[failure.id] = failure;
+          return acc;
+        }, {}),
+      [failed],
+    );
+
+    return (
+      <BaseRegistryArticle
+        {...props}
+        id={id}
+        plugins={plugins}
+        extraTagsById={extraTagsById}
+        failuresById={failuresById}
+        ref={forwardedRef}
+      />
+    );
+  },
+);
+
+RegistryArticle.displayName = 'RegistryArticle';

package/src/containers/RegistryArticle/index.ts

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

package/src/containers/RegistrySettingsContainer/RegistrySettingsContainer.tsx

@@ -0,0 +1,59 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { useAtomValue } from '@effect-atom/atom-react';
+import * as Effect from 'effect/Effect';
+import React, { useCallback } from 'react';
+
+import { useSettingsState, usePluginManager } from '@dxos/app-framework/ui';
+import { type AppCapabilities } from '@dxos/app-toolkit';
+import { runAndForwardErrors } from '@dxos/effect';
+
+import { RegistrySettings } from '../../components';
+import { type RegistrySettings as RegistrySettingsType } from '../../types';
+
+export type RegistrySettingsContainerProps = {
+  subject: AppCapabilities.Settings;
+};
+
+/**
+ * Wires the {@link RegistrySettings} presentational component to the plugin
+ * manager and the settings atom: subscribes to `manager.devPluginIds` for the
+ * "currently loaded" indicator and exposes enable/disable callbacks that drive
+ * the manager's add/enable/remove flow.
+ */
+export const RegistrySettingsContainer = ({ subject }: RegistrySettingsContainerProps) => {
+  const manager = usePluginManager();
+  const { settings, updateSettings } = useSettingsState<RegistrySettingsType>(subject.atom);
+  const activeDevPluginIds = useAtomValue(manager.devPluginIds);
+
+  const onEnableDev = useCallback(
+    async (url: string) => {
+      await runAndForwardErrors(
+        Effect.gen(function* () {
+          const plugin = yield* manager.add(url);
+          yield* manager.enable(plugin.meta.id);
+        }),
+      );
+    },
+    [manager],
+  );
+
+  const onDisableDev = useCallback(
+    async (id: string) => {
+      await runAndForwardErrors(manager.remove(id));
+    },
+    [manager],
+  );
+
+  return (
+    <RegistrySettings
+      settings={settings}
+      onSettingsChange={updateSettings}
+      activeDevPluginIds={activeDevPluginIds}
+      onEnableDev={onEnableDev}
+      onDisableDev={onDisableDev}
+    />
+  );
+};

package/src/containers/RegistrySettingsContainer/index.ts

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

package/src/containers/index.ts

@@ -0,0 +1,12 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { type ComponentType, lazy } from 'react';
+
+export { LOAD_PLUGIN_DIALOG } from './LoadPluginDialog/LoadPluginDialog';
+export const LoadPluginDialog: ComponentType<any> = lazy(() => import('./LoadPluginDialog'));
+export const PluginArticle: ComponentType<any> = lazy(() => import('./PluginArticle'));
+export const PublicRegistryArticle: ComponentType<any> = lazy(() => import('./PublicRegistryArticle'));
+export const RegistryArticle: ComponentType<any> = lazy(() => import('./RegistryArticle'));
+export const RegistrySettingsContainer: ComponentType<any> = lazy(() => import('./RegistrySettingsContainer'));

package/src/hooks/index.ts

@@ -0,0 +1,7 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+export * from './use-auto-tags';
+export * from './use-registry-plugins';
+export * from './use-update-available';

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

@@ -0,0 +1,51 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { useMemo } from 'react';
+
+import { type Registry, UrlLoader } from '@dxos/app-framework';
+
+/**
+ * Auto-tags that are derived at display time rather than persisted to `Plugin.Meta`.
+ * - `registry`: plugin id appears in the registry catalog 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 `registry` for any plugin id found in the supplied registry manifest entries.
+ */
+export const useAutoTags = (registryEntries: readonly Registry.Plugin[]): 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 registryEntries) {
+      addTag(entry.id, 'registry');
+    }
+
+    return byId;
+  }, [registryEntries]);
+
+/**
+ * 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-registry-plugins.ts

@@ -0,0 +1,29 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { useAtomValue } from '@effect-atom/atom-react';
+
+import { type Registry } from '@dxos/app-framework';
+import { usePluginManager } from '@dxos/app-framework/ui';
+
+/**
+ * Reads the registry plugin catalog from `manager.pluginRegistry.plugins`.
+ * The catalog is loaded once when the plugin manager is constructed (with a
+ * provider) so this hook is purely reactive — subscribers re-render as the
+ * `{entries, loading, error}` state settles.
+ */
+export const useRegistryPlugins = (): Registry.PluginsState => {
+  const manager = usePluginManager();
+  return useAtomValue(manager.pluginRegistry.plugins);
+};
+
+/**
+ * Returns the live `Registry.Manager` from the plugin manager so callers can
+ * issue `listVersions` / `getPlugin` calls directly. The catalog state itself
+ * is best read through {@link useRegistryPlugins} above.
+ */
+export const useRegistryPluginProvider = (): Registry.Manager => {
+  const manager = usePluginManager();
+  return manager.pluginRegistry;
+};

package/src/hooks/use-update-available.ts

@@ -0,0 +1,31 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { type Registry, UrlLoader } from '@dxos/app-framework';
+
+/**
+ * Returns a set of plugin ids for which the registry has a newer version
+ * than what was recorded at install time.
+ *
+ * Only flags plugins where a version was recorded at install time AND it differs
+ * from the catalog's current version. Legacy installs (no version stored) are ignored.
+ *
+ * NOTE: this is intentionally NOT memoised. The installed-version side of the
+ * comparison lives in localStorage and is mutated by `manager.add` /
+ * `manager.remove` / `UrlLoader.setInstalledVersion` outside React's view, so a
+ * memo keyed on `entries` would happily return stale data for the rest of the
+ * session after an update completes (the bug that produced "Update button
+ * reappears after Updating…"). The loop is O(catalog size) sync reads — cheap
+ * enough to do every render.
+ */
+export const useUpdateAvailableIds = (entries: readonly Registry.Plugin[]): ReadonlySet<string> => {
+  const ids = new Set<string>();
+  for (const entry of entries) {
+    const installedVersion = UrlLoader.getInstalledVersion(entry.id);
+    if (installedVersion !== undefined && installedVersion !== entry.version) {
+      ids.add(entry.id);
+    }
+  }
+  return ids;
+};

package/src/index.ts

@@ -3,4 +3,4 @@
 //
 
 export * from './meta';
-export * from './RegistryPlugin';
+export * from './storage';

package/src/meta.ts

@@ -2,17 +2,29 @@
 // Copyright 2023 DXOS.org
 //
 
-import { type PluginMeta } from '@dxos/app-framework';
+import { type Plugin } from '@dxos/app-framework';
+import { pinnedWorkspaceId } from '@dxos/app-toolkit';
+import { trim } from '@dxos/util';
 
-export const REGISTRY_PLUGIN = 'dxos.org/plugin/registry';
-
-// TODO(wittjosiah): Deck does not currently support `/` in ids.
-// TODO(wittjosiah): This is a hack to prevent the previous deck from being set for pinned items.
-//  Ideally this should be worked into the data model in a generic way.
-export const REGISTRY_ID = '!dxos:plugin-registry';
+export const REGISTRY_ID = pinnedWorkspaceId('dxos:plugin-registry');
 export const REGISTRY_KEY = 'plugin-registry';
 
-export const meta: PluginMeta = {
-  id: REGISTRY_PLUGIN,
+// TODO(wittjosiah): Should this be a special separator or use the standard path separator?
+const CATEGORY_SEPARATOR = '>';
+
+/** Build a registry category node ID. */
+export const registryCategoryId = (category: string): string => `${REGISTRY_KEY}${CATEGORY_SEPARATOR}${category}`;
+
+/** Qualified graph path to a specific plugin node. */
+export const getPluginPath = (pluginId: string): string => `root/${REGISTRY_ID}/${pluginId}`;
+
+export const meta: Plugin.Meta = {
+  id: 'org.dxos.plugin.registry',
   name: 'Plugins',
+  description: trim`
+    Plugin management system for discovering, installing, and configuring workspace extensions.
+    Browse available plugins and customize your workspace capabilities.
+  `,
+  icon: 'ph--squares-four--regular',
+  tags: ['system'],
 };

package/src/operations/index.ts

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

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

@@ -0,0 +1,21 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { LayoutOperation, SettingsOperation, getSpacePath } from '@dxos/app-toolkit';
+import { Operation } from '@dxos/compute';
+
+import { REGISTRY_ID } from '#meta';
+
+const handler: Operation.WithHandler<typeof SettingsOperation.OpenPluginRegistry> =
+  SettingsOperation.OpenPluginRegistry.pipe(
+    Operation.withHandler(
+      Effect.fnUntraced(function* () {
+        yield* Operation.invoke(LayoutOperation.SwitchWorkspace, { subject: getSpacePath(REGISTRY_ID) });
+      }),
+    ),
+  );
+
+export default handler;

package/src/plugin.ts

@@ -0,0 +1,11 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import { Plugin } from '@dxos/app-framework';
+
+import { meta } from './meta';
+
+export const RegistryPlugin = Plugin.lazy(meta, () => import('#plugin'));
+
+export { RegistryOperationHandlerSet } from './operations';

package/src/storage.ts

@@ -0,0 +1,50 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as FileSystem from '@effect/platform/FileSystem';
+import * as Path from '@effect/platform/Path';
+import * as Effect from 'effect/Effect';
+import * as Schema from 'effect/Schema';
+import * as Yaml from 'yaml';
+
+import { DX_CONFIG } from '@dxos/client-protocol';
+
+// TODO(wittjosiah): Factor out to app-framework?
+
+const PluginsSchema = Schema.Array(Schema.String);
+
+/** CLI-only: path to plugins/<profile>.yml (sibling to profile/). */
+const getPluginsConfigPath = (profile: string) => `${DX_CONFIG}/plugins/${profile}.yml`;
+
+/**
+ * Load enabled plugins from plugins/<profile>.yml (sibling to profile/).
+ * Returns the list of enabled plugin IDs, or an empty array if the file doesn't exist.
+ */
+export const loadEnabledPlugins = Effect.fn(function* ({ profile }: { profile: string }) {
+  const fs = yield* FileSystem.FileSystem;
+  const pluginsPath = getPluginsConfigPath(profile);
+
+  const content = yield* fs
+    .readFileString(pluginsPath)
+    .pipe(Effect.catchTag('SystemError', () => Effect.succeed('[]')));
+
+  const raw = Yaml.parse(content);
+  const parsed = yield* Schema.decodeUnknown(PluginsSchema)(raw ?? []).pipe(
+    Effect.catchAll(() => Effect.succeed([] as string[])),
+  );
+
+  return parsed;
+});
+
+/**
+ * Save enabled plugins to plugins/<profile>.yml.
+ */
+export const saveEnabledPlugins = Effect.fn(function* ({ profile, enabled }: { profile: string; enabled: string[] }) {
+  const fs = yield* FileSystem.FileSystem;
+  const path = yield* Path.Path;
+  const pluginsPath = getPluginsConfigPath(profile);
+  yield* fs.makeDirectory(path.dirname(pluginsPath), { recursive: true });
+  const encoded = Yaml.stringify(enabled);
+  yield* fs.writeFileString(pluginsPath, encoded);
+});