fix: update version code and name in build.gradle; register PluginStoragePlugin in MainActivity; enhance text duplication handling in Editor component

overlay/src/app/components/editor/Editor.tsx

@@ -18,6 +18,7 @@ import {
   RenderLeafProps,
   RenderElementProps,
   RenderPlaceholderProps,
+  ReactEditor,
 } from 'slate-react';
 import { withHistory } from 'slate-history';
 import { BlockType } from './types';
@@ -172,27 +173,44 @@ export const CustomEditor = forwardRef<HTMLDivElement, CustomEditorProps>(
     const handleBeforeInput = useCallback(
       (event: Event) => {
         const inputEvent = event as InputEvent;
-        
-        // Handle autocorrect replacement that causes text duplication
-        if (inputEvent.inputType === 'insertReplacementText' || 
-            inputEvent.inputType === 'insertFromComposition') {
+
+        // Handle mobile autocorrect replacement that causes text duplication in Slate
+        if (inputEvent.inputType === 'insertReplacementText') {
+          const data = inputEvent.data || inputEvent.dataTransfer?.getData('text/plain');
+          if (!data) return;
+
+          event.preventDefault();
+
+          const domRanges = inputEvent.getTargetRanges?.() ?? [];
+          if (domRanges.length > 0) {
+            const slateRange = ReactEditor.toSlateRange(editor, domRanges[0], {
+              exactMatch: false,
+              suppressThrow: true,
+            });
+
+            if (slateRange) {
+              Transforms.select(editor, slateRange);
+              Transforms.delete(editor);
+              editor.insertText(data);
+              return;
+            }
+          }
+
           const { selection } = editor;
           if (!selection) return;
 
-          // Get the data being inserted
-          const data = inputEvent.data || inputEvent.dataTransfer?.getData('text/plain');
-          
-          if (data) {
-            event.preventDefault();
-            
-            // If there's selected text, delete it first
-            if (selection && !Range.isCollapsed(selection)) {
-              Transforms.delete(editor, { at: selection });
+          if (!Range.isCollapsed(selection)) {
+            Transforms.delete(editor, { at: selection });
+          } else {
+            const wordBefore = Editor.before(editor, selection.anchor, { unit: 'word' });
+            if (wordBefore) {
+              const wordRange = { anchor: wordBefore, focus: selection.anchor };
+              Transforms.select(editor, wordRange);
+              Transforms.delete(editor);
             }
-            
-            // Insert the replacement text
-            editor.insertText(data);
           }
+
+          editor.insertText(data);
         }
       },
       [editor]

overlay/src/app/features/settings/plugins/PluginAPI.ts

@@ -0,0 +1,149 @@
+/**
+ * Re-exports the full @paarrot/plugin-manager API and creates the shared
+ * singleton PluginRegistry instance for this application.
+ *
+ * All other modules in this folder should import from here rather than
+ * directly from the package so the singleton is guaranteed to be shared.
+ */
+export {
+  PluginMarketplaceClient,
+  PluginMarketplaceManager,
+  PluginRegistry,
+  createPluginContext,
+  generateThemeCSS,
+  MemoryStorage,
+} from '@paarrot/plugin-manager';
+
+export type {
+  IPluginStorage,
+  IPluginEventClient,
+  PluginMarketplaceClientOptions,
+  PluginMarketplaceHostAdapter,
+  PluginMarketplaceInstalledRecord,
+  PluginMarketplaceManagerOptions,
+  PluginRegistryOptions,
+  PluginContextOptions,
+  PluginMetadata,
+  InstalledPlugin,
+  PluginIndex,
+  ThemeColorGroup,
+  ThemePaletteGroup,
+  PluginThemeColors,
+  PluginTheme,
+  CommandArg,
+  PluginCommand,
+  MessageInterceptor,
+  MessageContext,
+  CustomRenderer,
+  SettingDefinition,
+  SettingsSchema,
+  NotificationOptions,
+  PluginContext,
+  PluginSettingsSection,
+  UILocation,
+  UIButtonDefinition,
+  UIButtonPosition,
+  Plugin,
+  PluginLogEntry,
+} from '@paarrot/plugin-manager';
+
+export { PluginTab } from '@paarrot/plugin-manager';
+
+import {
+  PluginMarketplaceClient,
+  PluginMarketplaceManager,
+  PluginRegistry,
+} from '@paarrot/plugin-manager';
+import { getPluginHost } from '../../../utils/pluginHost';
+
+const PLUGIN_INDEX_URL =
+  import.meta.env.VITE_PLUGIN_INDEX_URL ||
+  `https://raw.githubusercontent.com/Paarrot/Plugin-Directory/refs/heads/main/plugins/index.json?cache_burst=${(Math.random()*256).toString()}`;
+const PLUGIN_BASE_URL =
+  import.meta.env.VITE_PLUGIN_BASE_URL ||
+  'https://raw.githubusercontent.com/Paarrot/Plugin-Directory/refs/heads/main/plugins/';
+
+function injectThemeStyle(styleId: string, css: string): void {
+  let el = document.getElementById(styleId) as HTMLStyleElement | null;
+  if (!el) {
+    el = document.createElement('style');
+    el.id = styleId;
+    document.head.appendChild(el);
+  }
+  el.textContent = css;
+}
+
+function removeThemeStyle(styleId: string): void {
+  document.getElementById(styleId)?.remove();
+}
+
+/** Shared singleton registry for the entire application. */
+export const pluginRegistry = new PluginRegistry({
+  storage: localStorage,
+  onThemeRegistered: (themeId, _className, css) =>
+    injectThemeStyle(`plugin-theme-${themeId}`, css),
+  onThemeUnregistered: (themeId) => removeThemeStyle(`plugin-theme-${themeId}`),
+});
+
+/** Shared marketplace client for remote plugin directory reads. */
+export const pluginMarketplaceClient = new PluginMarketplaceClient({
+  indexUrl: PLUGIN_INDEX_URL,
+  baseUrl: PLUGIN_BASE_URL,
+});
+
+/**
+ * Shared marketplace manager for install state, directory fetch, and enable flags.
+ */
+export const pluginMarketplaceManager = new PluginMarketplaceManager({
+  client: pluginMarketplaceClient,
+  storage: localStorage,
+  registry: pluginRegistry,
+  host: {
+    listInstalledPlugins: async () => {
+      const host = getPluginHost();
+      if (!host) {
+        return [];
+      }
+
+      const result = await host.list();
+      if (!result.success || !result.data) {
+        throw new Error(result.error ?? 'Failed to list installed plugins');
+      }
+
+      return result.data.map((plugin) => ({
+        id: plugin.id,
+        name: plugin.name,
+        version: plugin.version,
+        description: plugin.description,
+        author: plugin.author,
+        repository: plugin.repository,
+        thumbnail: plugin.thumbnail,
+        homepage: plugin.homepage,
+        tags: plugin.tags,
+        installedDate: plugin.installedDate,
+      }));
+    },
+    installPlugin: async (plugin) => {
+      const host = getPluginHost();
+      if (!host) {
+        return;
+      }
+
+      const result = await host.download(plugin.id, plugin.downloadUrl, plugin.name);
+      if (!result.success) {
+        throw new Error(result.error ?? 'Failed to install plugin');
+      }
+    },
+    uninstallPlugin: async (pluginId) => {
+      const host = getPluginHost();
+      if (!host) {
+        return;
+      }
+
+      const result = await host.uninstall(pluginId);
+      if (!result.success) {
+        throw new Error(result.error ?? 'Failed to uninstall plugin');
+      }
+    },
+  },
+});

overlay/src/app/features/settings/plugins/PluginLoader.tsx

@@ -0,0 +1,190 @@
+import React, { useEffect } from 'react';
+import { MatrixClient } from 'matrix-js-sdk';
+import { Plugin, createPluginContext } from '@paarrot/plugin-manager';
+import { pluginMarketplaceManager, pluginRegistry } from './PluginAPI';
+import { sendNotification } from '../../../utils/tauri';
+import { getPluginHost } from '../../../utils/pluginHost';
+import { dispatchPluginButtonsChanged } from './PluginButtonSlot';
+
+interface PluginLoaderProps {
+  matrixClient: MatrixClient;
+  children: React.ReactNode;
+}
+
+/**
+ * Component that loads and initializes enabled plugins.
+ * Should be placed high in the component tree after MatrixClient is available.
+ */
+export function PluginLoader({ matrixClient, children }: PluginLoaderProps) {
+  console.log('[PluginLoader] Component rendering, matrixClient:', !!matrixClient);
+
+  useEffect(() => {
+    const loadPlugins = async () => {
+      try {
+        const pluginHost = getPluginHost();
+        console.log('[PluginLoader] Loading plugins...');
+        console.log('[PluginLoader] plugin host available:', !!pluginHost);
+
+        if (!pluginHost) {
+          console.log('[PluginLoader] Running in web mode, plugins not supported');
+          return;
+        }
+
+        const pluginsToLoad = await pluginMarketplaceManager.listEnabledPlugins();
+
+        console.log('[PluginLoader] Plugins to load:', pluginsToLoad.length);
+        console.log('[PluginLoader] Plugin list:', pluginsToLoad.map((p) => p.id));
+
+        for (const installedPlugin of pluginsToLoad) {
+          try {
+            console.log(`[PluginLoader] Loading plugin: ${installedPlugin.id}`);
+
+            const pluginModule = await loadPluginModule(installedPlugin.id);
+            const plugin = normalisePlugin(pluginModule);
+
+            if (!plugin || typeof plugin !== 'object') {
+              console.error(
+                `[PluginLoader] Plugin ${installedPlugin.id} does not export a valid plugin object`
+              );
+              continue;
+            }
+
+            if (typeof plugin.onLoad !== 'function') {
+              console.error(
+                `[PluginLoader] Plugin ${installedPlugin.id} does not have an onLoad function`
+              );
+              continue;
+            }
+
+            const context = createPluginContext(
+              {
+                pluginId: installedPlugin.id,
+                eventClient: matrixClient as any,
+                onNotify: async (opts) => {
+                  await sendNotification({
+                    title: opts.title,
+                    body: opts.body,
+                    path: undefined,
+                  });
+                },
+              },
+              pluginRegistry
+            );
+
+            const compatContext = Object.assign(context as Record<string, unknown>, {
+              matrixClient,
+              matrix: {
+                on: (eventType: string, handler: (...args: unknown[]) => void) =>
+                  matrixClient.on(eventType as any, handler as any),
+                off: (eventType: string, handler: (...args: unknown[]) => void) =>
+                  matrixClient.off(eventType as any, handler as any),
+              },
+              React,
+            });
+
+            console.log('[PluginLoader] compatContext.React:', !!compatContext.React);
+            console.log('[PluginLoader] compatContext.ui:', !!compatContext.ui);
+            console.log('[PluginLoader] About to register plugin and call onLoad...');
+
+            pluginRegistry.registerPlugin(installedPlugin.id, plugin, context);
+            await plugin.onLoad(compatContext as any);
+            console.log(`[PluginLoader] Successfully loaded plugin: ${installedPlugin.id}`);
+            dispatchPluginButtonsChanged();
+          } catch (error) {
+            console.error(`[PluginLoader] Failed to load plugin ${installedPlugin.id}:`, error);
+            pluginRegistry.addLog(installedPlugin.id, 'error', ['Failed to load:', error]);
+          }
+        }
+      } catch (error) {
+        console.error('[PluginLoader] Error loading plugins:', error);
+      }
+    };
+
+    loadPlugins();
+
+    return () => {
+      console.log('[PluginLoader] Cleaning up plugins');
+      pluginRegistry.clear();
+      dispatchPluginButtonsChanged();
+    };
+  }, [matrixClient]);
+
+  return <>{children}</>;
+}
+
+/**
+ * Reads and evaluates a plugin's JS module from the native filesystem host.
+ * Supports both CommonJS and ESM-style exports.
+ */
+async function loadPluginModule(pluginId: string): Promise<any> {
+  const pluginHost = getPluginHost();
+  if (!pluginHost) {
+    throw new Error('Plugins are only supported in the desktop or Android app');
+  }
+
+  const response = await pluginHost.readPluginCode(pluginId);
+  if (!response.success || !response.data) {
+    throw new Error(response.error ?? 'Failed to read plugin code');
+  }
+
+  const pluginExports: any = {};
+  const mod = { exports: pluginExports };
+
+  try {
+    // eslint-disable-next-line no-new-func
+    const pluginFunction = new Function('module', 'exports', response.data);
+    pluginFunction(mod, pluginExports);
+  } catch (error) {
+    if (!(error instanceof SyntaxError)) {
+      throw error;
+    }
+
+    const dataUrl = `data:text/javascript;charset=utf-8,${encodeURIComponent(response.data)}`;
+    const importedModule = await import(/* @vite-ignore */ dataUrl);
+    return importedModule;
+  }
+
+  return mod.exports;
+}
+
+/**
+ * Normalizes raw plugin exports to current plugin interface.
+ * Supports native `onLoad` and legacy `activate` / `deactivate` plugins.
+ */
+function normalisePlugin(raw: Record<string, unknown>): Plugin {
+  if (typeof raw.onLoad === 'function') {
+    return raw as unknown as Plugin;
+  }
+
+  if (typeof raw.activate === 'function') {
+    const activate = raw.activate as (ctx: unknown) => void | Promise<void>;
+    const deactivate = raw.deactivate as ((ctx?: unknown) => void | Promise<void>) | undefined;
+
+    return {
+      name: typeof raw.name === 'string' ? raw.name : undefined,
+      version: typeof raw.version === 'string' ? raw.version : undefined,
+      onLoad: async (ctx) => {
+        const legacyCtx = Object.assign(Object.create(ctx as object), {
+          registerHook: (name: string) =>
+            ctx.log(`[compat] registerHook("${name}") - not supported`),
+          runHook: (name: string) => {
+            ctx.log(`[compat] runHook("${name}")`);
+            return Promise.resolve([]);
+          },
+          getConfig: (key: string) => ctx.settings.get(key),
+          on: (event: string, handler: (...args: unknown[]) => void) =>
+            ctx.events.on(event, handler),
+        });
+
+        await activate(legacyCtx);
+      },
+      onUnload: deactivate
+        ? async () => {
+            await deactivate();
+          }
+        : undefined,
+    };
+  }
+
+  return raw as unknown as Plugin;
+}

overlay/src/app/utils/pluginHost.ts

@@ -0,0 +1,72 @@
+import { Capacitor, registerPlugin } from '@capacitor/core';
+
+export type PluginHostListItem = {
+  id: string;
+  name: string;
+  version?: string;
+  description?: string;
+  author?: string;
+  repository?: string;
+  thumbnail?: string;
+  homepage?: string;
+  tags?: string[];
+  installedDate: string;
+  path: string;
+};
+
+export type PluginHostResult<T> = {
+  success: boolean;
+  data?: T;
+  error?: string;
+};
+
+export interface PluginHostAPI {
+  getPath: () => Promise<PluginHostResult<string>>;
+  download: (
+    pluginId: string,
+    downloadUrl: string,
+    name: string
+  ) => Promise<PluginHostResult<{ path: string }>>;
+  list: () => Promise<PluginHostResult<PluginHostListItem[]>>;
+  uninstall: (pluginId: string) => Promise<PluginHostResult<void>>;
+  readPluginCode: (pluginId: string) => Promise<PluginHostResult<string>>;
+}
+
+interface PluginStoragePlugin {
+  getPath(): Promise<PluginHostResult<string>>;
+  download(options: {
+    pluginId: string;
+    downloadUrl: string;
+    name: string;
+  }): Promise<PluginHostResult<{ path: string }>>;
+  list(): Promise<PluginHostResult<PluginHostListItem[]>>;
+  uninstall(options: { pluginId: string }): Promise<PluginHostResult<void>>;
+  readPluginCode(options: { pluginId: string }): Promise<PluginHostResult<string>>;
+}
+
+const PluginStorage = registerPlugin<PluginStoragePlugin>('PluginStorage');
+
+const androidPluginHost: PluginHostAPI = {
+  getPath: () => PluginStorage.getPath(),
+  download: (pluginId, downloadUrl, name) =>
+    PluginStorage.download({ pluginId, downloadUrl, name }),
+  list: () => PluginStorage.list(),
+  uninstall: (pluginId) => PluginStorage.uninstall({ pluginId }),
+  readPluginCode: (pluginId) => PluginStorage.readPluginCode({ pluginId }),
+};
+
+/** Returns true when a native plugin filesystem host is available. */
+export const isPluginHostSupported = (): boolean => getPluginHost() !== null;
+
+/** Returns the active plugin host for Electron or Android. */
+export const getPluginHost = (): PluginHostAPI | null => {
+  if (window.electron?.plugins) {
+    return window.electron.plugins;
+  }
+
+  if (Capacitor.isNativePlatform() && Capacitor.getPlatform() === 'android') {
+    return androidPluginHost;
+  }
+
+  return null;
+};