@dxos/plugin-native 0.8.4-main.3fbcb4aa9b → 0.8.4-main.4668b7de9b

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dxos/plugin-native",
-  "version": "0.8.4-main.3fbcb4aa9b",
+  "version": "0.8.4-main.4668b7de9b",
   "description": "Composer plugin that runs when on a native device.",
   "homepage": "https://dxos.org",
   "bugs": "https://github.com/dxos/dxos/issues",
@@ -8,7 +8,7 @@
     "type": "git",
     "url": "https://github.com/dxos/dxos"
   },
-  "license": "MIT",
+  "license": "FSL-1.1-Apache-2.0",
   "author": "DXOS.org",
   "sideEffects": true,
   "type": "module",
@@ -18,6 +18,11 @@
       "types": "./dist/types/src/capabilities/index.d.ts",
       "default": "./dist/lib/neutral/capabilities/index.mjs"
     },
+    "#components": {
+      "source": "./src/components/index.ts",
+      "types": "./dist/types/src/components/index.d.ts",
+      "default": "./dist/lib/neutral/components/index.mjs"
+    },
     "#meta": {
       "source": "./src/meta.ts",
       "types": "./dist/types/src/meta.d.ts",
@@ -32,6 +37,11 @@
       "source": "./src/translations.ts",
       "types": "./dist/types/src/translations.d.ts",
       "default": "./dist/lib/neutral/translations.mjs"
+    },
+    "#types": {
+      "source": "./src/types/index.ts",
+      "types": "./dist/types/src/types/index.d.ts",
+      "default": "./dist/lib/neutral/types/index.mjs"
     }
   },
   "exports": {
@@ -40,6 +50,7 @@
       "types": "./dist/types/src/index.d.ts",
       "default": "./dist/lib/neutral/index.mjs"
     },
+    "./assets/PLUGIN.mdl": "./PLUGIN.mdl",
     "./plugin": {
       "source": "./src/plugin.ts",
       "types": "./dist/types/src/plugin.d.ts",
@@ -54,34 +65,41 @@
   "types": "dist/types/src/index.d.ts",
   "files": [
     "dist",
-    "src"
+    "src",
+    "PLUGIN.mdl"
   ],
   "dependencies": {
+    "@effect-atom/atom-react": "^0.5.0",
     "@effect/platform": "0.94.4",
-    "@tauri-apps/api": "^2.8.0",
-    "@tauri-apps/plugin-os": "^2.3.1",
-    "@tauri-apps/plugin-process": "^2.3.0",
-    "@tauri-apps/plugin-shell": "^2.3.1",
-    "@tauri-apps/plugin-updater": "^2.9.0",
-    "effect": "3.20.0",
-    "@dxos/app-toolkit": "0.8.4-main.3fbcb4aa9b",
-    "@dxos/ai": "0.8.4-main.3fbcb4aa9b",
-    "@dxos/operation": "0.8.4-main.3fbcb4aa9b",
-    "@dxos/plugin-assistant": "0.8.4-main.3fbcb4aa9b",
-    "@dxos/log": "0.8.4-main.3fbcb4aa9b",
-    "@dxos/plugin-help": "0.8.4-main.3fbcb4aa9b",
-    "@dxos/app-framework": "0.8.4-main.3fbcb4aa9b",
-    "@dxos/plugin-navtree": "0.8.4-main.3fbcb4aa9b",
-    "@dxos/util": "0.8.4-main.3fbcb4aa9b"
+    "@tauri-apps/api": "^2.11.0",
+    "@tauri-apps/plugin-os": "^2.3.2",
+    "@tauri-apps/plugin-process": "^2.3.1",
+    "@tauri-apps/plugin-shell": "^2.3.5",
+    "@tauri-apps/plugin-updater": "^2.10.1",
+    "date-fns": "^3.6.0",
+    "@dxos/ai": "0.8.4-main.4668b7de9b",
+    "@dxos/app-framework": "0.8.4-main.4668b7de9b",
+    "@dxos/app-toolkit": "0.8.4-main.4668b7de9b",
+    "@dxos/log": "0.8.4-main.4668b7de9b",
+    "@dxos/effect": "0.8.4-main.4668b7de9b",
+    "@dxos/plugin-assistant": "0.8.4-main.4668b7de9b",
+    "@dxos/util": "0.8.4-main.4668b7de9b",
+    "@dxos/keys": "0.8.4-main.4668b7de9b"
   },
   "devDependencies": {
-    "vite": "^8.0.10",
-    "@dxos/plugin-testing": "0.8.4-main.3fbcb4aa9b",
-    "@dxos/react-ui": "0.8.4-main.3fbcb4aa9b"
+    "@types/react": "~19.2.7",
+    "effect": "3.20.0",
+    "react": "~19.2.3",
+    "vite": "^8.0.14",
+    "@dxos/plugin-testing": "0.8.4-main.4668b7de9b",
+    "@dxos/react-ui": "0.8.4-main.4668b7de9b",
+    "@dxos/react-ui-form": "0.8.4-main.4668b7de9b"
   },
   "peerDependencies": {
     "effect": "3.20.0",
-    "@dxos/react-ui": "0.8.4-main.3fbcb4aa9b"
+    "react": "~19.2.3",
+    "@dxos/react-ui": "0.8.4-main.4668b7de9b",
+    "@dxos/react-ui-form": "0.8.4-main.4668b7de9b"
   },
   "publishConfig": {
     "access": "public"

package/src/NativePlugin.tsx

@@ -6,20 +6,25 @@ import { ActivationEvents, Plugin } from '@dxos/app-framework';
 import { AppPlugin } from '@dxos/app-toolkit';
 import { AssistantEvents } from '@dxos/plugin-assistant';
 
-import { Ollama, SpotlightListener, Updater } from '#capabilities';
+import { NativeSettings, Ollama, ReactSurface, SpotlightListener, Updater } from '#capabilities';
 import { meta } from '#meta';
 import { translations } from '#translations';
 
+// eslint-disable-next-line import/no-relative-packages
+import pluginSpec from '../PLUGIN.mdl?raw';
+
 export const NativePlugin = Plugin.define(meta).pipe(
+  AppPlugin.addSettingsModule({ activate: NativeSettings }),
+  AppPlugin.addSurfaceModule({ activate: ReactSurface }),
   AppPlugin.addTranslationsModule({ translations }),
   Plugin.addModule({
     id: 'spotlight-listener',
-    activatesOn: ActivationEvents.OperationInvokerReady,
+    activatesOn: ActivationEvents.ProcessManagerReady,
     activate: SpotlightListener,
   }),
   Plugin.addModule({
     id: 'updater',
-    activatesOn: ActivationEvents.OperationInvokerReady,
+    activatesOn: ActivationEvents.ProcessManagerReady,
     activate: Updater,
   }),
   Plugin.addModule({
@@ -27,6 +32,9 @@ export const NativePlugin = Plugin.define(meta).pipe(
     activatesOn: AssistantEvents.SetupAiServiceProviders,
     activate: Ollama,
   }),
+  AppPlugin.addPluginAssetModule({
+    asset: { pluginId: meta.id, path: 'PLUGIN.mdl', content: pluginSpec, mimeType: 'application/x-mdl' },
+  }),
   Plugin.make,
 );
 

package/src/capabilities/index.ts

@@ -4,6 +4,8 @@
 
 import { Capability } from '@dxos/app-framework';
 
+export const NativeSettings = Capability.lazy('NativeSettings', () => import('./settings'));
 export const Ollama = Capability.lazy('Ollama', () => import('./ollama'));
+export const ReactSurface = Capability.lazy('ReactSurface', () => import('./react-surface'));
 export const SpotlightListener = Capability.lazy('SpotlightListener', () => import('./spotlight-listener'));
 export const Updater = Capability.lazy('Updater', () => import('./updater'));

package/src/capabilities/react-surface.tsx

@@ -0,0 +1,29 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+import React from 'react';
+
+import { Capabilities, Capability } from '@dxos/app-framework';
+import { Surface, useSettingsState } from '@dxos/app-framework/ui';
+import { AppSurface } from '@dxos/app-toolkit/ui';
+
+import { NativeSettings } from '#components';
+import { meta } from '#meta';
+import { type Settings } from '#types';
+
+export default Capability.makeModule(() =>
+  Effect.succeed(
+    Capability.contributes(Capabilities.ReactSurface, [
+      Surface.create({
+        id: 'pluginSettings',
+        filter: AppSurface.settings(AppSurface.Article, meta.id),
+        component: ({ data: { subject } }) => {
+          const { settings, updateSettings } = useSettingsState<Settings.Settings>(subject.atom);
+          return <NativeSettings settings={settings} onSettingsChange={updateSettings} />;
+        },
+      }),
+    ]),
+  ),
+);

package/src/capabilities/settings.ts

@@ -0,0 +1,31 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Capability } from '@dxos/app-framework';
+import { AppCapabilities } from '@dxos/app-toolkit';
+import { createKvsStore } from '@dxos/effect';
+
+import { meta } from '#meta';
+import { NativeCapabilities, Settings } from '#types';
+
+export default Capability.makeModule(() =>
+  Effect.sync(() => {
+    const settingsAtom = createKvsStore({
+      key: meta.id,
+      schema: Settings.Settings,
+      defaultValue: () => ({}),
+    });
+
+    return [
+      Capability.contributes(NativeCapabilities.Settings, settingsAtom),
+      Capability.contributes(AppCapabilities.Settings, {
+        prefix: meta.id,
+        schema: Settings.Settings,
+        atom: settingsAtom,
+      }),
+    ];
+  }),
+);

package/src/capabilities/updater.ts

@@ -2,6 +2,7 @@
 // Copyright 2025 DXOS.org
 //
 
+import { Atom } from '@effect-atom/atom-react';
 import { type } from '@tauri-apps/plugin-os';
 import { relaunch } from '@tauri-apps/plugin-process';
 import * as Updater from '@tauri-apps/plugin-updater';
@@ -16,114 +17,178 @@ import { LayoutOperation } from '@dxos/app-toolkit';
 import { log } from '@dxos/log';
 
 import { meta } from '#meta';
+import { NativeCapabilities, type Update } from '#types';
 
 import { TAURI_LOCALHOST_PORT } from '../constants';
 
 const SUPPORTS_OTA = ['linux', 'macos', 'windows'];
 
-/**
- * Safely check for updates with error logging.
- */
-const check = async (): Promise<Updater.Update | null> => {
+/** Safe wrapper around Updater.check(). Distinguishes "no update" (ok with null update) from a thrown error. */
+const safeCheck = async (): Promise<{ ok: true; update: Updater.Update | null } | { ok: false; error: string }> => {
   try {
-    return await Updater.check();
+    return { ok: true, update: await Updater.check() };
   } catch (error) {
     log.error('failed to check for updates', { error });
-    return null;
+    return { ok: false, error: formatError(error) };
   }
 };
 
-/**
- * Safely download and install update with error logging.
- */
-const downloadAndInstall = async (
+/** Safe wrapper around update.downloadAndInstall(). */
+const safeDownloadAndInstall = async (
   update: Updater.Update,
-  handleDownload: (event: Updater.DownloadEvent) => void,
-): Promise<boolean> => {
+  onEvent: (event: Updater.DownloadEvent) => void,
+): Promise<{ ok: true } | { ok: false; error: string }> => {
   try {
-    await update.downloadAndInstall(handleDownload);
-    return true;
+    await update.downloadAndInstall(onEvent);
+    return { ok: true };
   } catch (error) {
     log.error('failed to download and install update', { error });
-    return false;
+    return { ok: false, error: formatError(error) };
   }
 };
 
+/** Extract a user-readable error string from whatever the Tauri updater threw. */
+const formatError = (error: unknown): string => {
+  if (typeof error === 'string') {
+    return error;
+  }
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return String(error);
+};
+
 export default Capability.makeModule(
   Effect.fnUntraced(function* () {
-    // Skip updates if not supported or in dev mode.
     const platform = type();
     const isDevServer = window.location.port !== TAURI_LOCALHOST_PORT;
-    if (!SUPPORTS_OTA.includes(platform) || isDevServer) {
-      log.info('skipping updater', { platform, port: window.location.port });
-      return;
-    }
+    const enabled = SUPPORTS_OTA.includes(platform) && !isDevServer;
 
+    const registry = yield* Capability.get(Capabilities.AtomRegistry);
     const { invoke } = yield* Capability.get(Capabilities.OperationInvoker);
 
-    // https://tauri.app/plugin/updater/#checking-for-updates
-    // Returns true to keep checking, false to stop.
-    const action = Effect.gen(function* () {
+    const statusAtom = Atom.make<Update.Status>(enabled ? { kind: 'idle' } : { kind: 'unsupported' }).pipe(
+      Atom.keepAlive,
+    );
+
+    // Updater.Update is a class with instance methods (downloadAndInstall) and can't live in an
+    // atom value; cache it here between check and install.
+    let pendingUpdate: Updater.Update | null = null;
+
+    // Core: check for an update and update the status atom. Returns the update if available.
+    const doCheck = async (): Promise<Updater.Update | null> => {
+      registry.set(statusAtom, { kind: 'checking' });
       log.info('checking for updates');
-      const update = yield* Effect.promise(() => check());
+      const result = await safeCheck();
+      if (!result.ok) {
+        pendingUpdate = null;
+        registry.set(statusAtom, { kind: 'failed', error: result.error });
+        return null;
+      }
+      const update = result.update;
+      if (!update?.available) {
+        pendingUpdate = null;
+        registry.set(statusAtom, { kind: 'up-to-date', checkedAt: Date.now() });
+        return null;
+      }
+      log.info('update available', { version: update.version });
+      pendingUpdate = update;
+      registry.set(statusAtom, { kind: 'available', version: update.version });
+      return update;
+    };
+
+    // Core: download + install the cached pending update, streaming progress to the status atom.
+    const doInstall = async (): Promise<boolean> => {
+      const update = pendingUpdate;
       if (!update) {
-        log.info('no update available');
+        return false;
+      }
+      let downloaded = 0;
+      let contentLength = 0;
+      registry.set(statusAtom, { kind: 'downloading', downloaded: 0, contentLength: 0 });
+      const onEvent = Match.type<Updater.DownloadEvent>().pipe(
+        Match.when({ event: 'Started' }, (event) => {
+          contentLength = event.data.contentLength ?? 0;
+          registry.set(statusAtom, { kind: 'downloading', downloaded, contentLength });
+        }),
+        Match.when({ event: 'Progress' }, (event) => {
+          downloaded += event.data.chunkLength;
+          registry.set(statusAtom, { kind: 'downloading', downloaded, contentLength });
+        }),
+        Match.when({ event: 'Finished' }, () => {
+          log.info('download completed');
+        }),
+        Match.exhaustive,
+      );
+      const result = await safeDownloadAndInstall(update, onEvent);
+      if (result.ok) {
+        registry.set(statusAtom, { kind: 'ready' });
         return true;
       }
-      log.info('update check complete', {
-        available: update.available,
-        currentVersion: update.currentVersion,
-        version: update.version,
-        date: update.date,
-        body: update.body,
-      });
-      if (update.available) {
-        log.info('update available, starting download', { version: update.version });
-        let downloaded = 0;
-        let contentLength = 0;
-
-        const handleDownload = Match.type<Updater.DownloadEvent>().pipe(
-          Match.when({ event: 'Started' }, (event) => {
-            contentLength = event.data.contentLength ?? 0;
-            log.info('download started', { contentLength });
-          }),
-          Match.when({ event: 'Progress' }, (event) => {
-            downloaded += event.data.chunkLength;
-            log.verbose('download progress', { downloaded, contentLength });
-          }),
-          Match.when({ event: 'Finished' }, () => {
-            log.info('download completed');
-          }),
-          Match.exhaustive,
-        );
-
-        const downloadSuccess = yield* Effect.promise(() => downloadAndInstall(update, handleDownload));
-
-        if (downloadSuccess) {
-          yield* invoke(LayoutOperation.AddToast, {
-            id: `${meta.id}.update-ready`,
-            title: ['update-ready.label', { ns: meta.id }],
-            description: ['update-ready.description', { ns: meta.id }],
-            duration: Infinity,
-            actionLabel: ['update.label', { ns: meta.id }],
-            actionAlt: ['update.alt', { ns: meta.id }],
-            onAction: () => relaunch(),
-          });
-          return false;
+      registry.set(statusAtom, { kind: 'failed', error: result.error });
+      return false;
+    };
+
+    const manager: Update.Manager = {
+      status: statusAtom,
+      check: async () => {
+        if (!enabled) {
+          return;
+        }
+        await doCheck();
+      },
+      install: async () => {
+        if (!enabled) {
+          return;
         }
+        await doInstall();
+      },
+      relaunch: async () => {
+        await relaunch();
+      },
+    };
+
+    const managerContribution = Capability.contributes(NativeCapabilities.UpdateManager, manager);
+
+    if (!enabled) {
+      log.info('updater disabled', { platform, port: window.location.port });
+      return [managerContribution];
+    }
+
+    // Background flow: periodic check + auto-install + toast when ready.
+    // The toast is the entry point for users who weren't watching the settings panel.
+    const backgroundAction = Effect.gen(function* () {
+      const update = yield* Effect.promise(() => doCheck());
+      if (!update) {
+        return true;
+      }
+      const ok = yield* Effect.promise(() => doInstall());
+      if (!ok) {
+        return true;
       }
-      return true;
+      yield* invoke(LayoutOperation.AddToast, {
+        id: `${meta.id}.update-ready`,
+        title: ['update-ready.label', { ns: meta.id }],
+        description: ['update-ready.description', { ns: meta.id }],
+        duration: Infinity,
+        actionLabel: ['update.label', { ns: meta.id }],
+        actionAlt: ['update.alt', { ns: meta.id }],
+        onAction: () => relaunch(),
+      });
+      return false;
     });
 
-    // Run immediately on startup, then repeat every hour. Stop once an update is found.
     const schedule = Schedule.fixed(Duration.hours(1)).pipe(
       Schedule.whileInput((keepChecking: boolean) => keepChecking),
     );
-    const fiber = yield* action.pipe(Effect.repeat(schedule), Effect.forkDaemon);
+    const fiber = yield* backgroundAction.pipe(Effect.repeat(schedule), Effect.forkDaemon);
     log.info('updater module initialized, update check scheduled');
 
-    return Capability.contributes(Capabilities.Null, null, () =>
-      Effect.sync(() => Effect.runSync(Fiber.interrupt(fiber))),
-    );
+    return [
+      managerContribution,
+      // Return the interruption effect directly; Fiber.interrupt is async and would throw
+      // AsyncFiberException if wrapped in Effect.runSync.
+      Capability.contributes(Capabilities.Null, null, () => Fiber.interrupt(fiber)),
+    ];
   }),
 );

package/src/components/NativeSettings/NativeSettings.tsx

@@ -0,0 +1,132 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { useAtomValue } from '@effect-atom/atom-react';
+import { formatDistanceToNow } from 'date-fns/formatDistanceToNow';
+import * as Match from 'effect/Match';
+import React, { type ReactNode, useState } from 'react';
+
+import { useCapability } from '@dxos/app-framework/ui';
+import { type AppSurface } from '@dxos/app-toolkit/ui';
+import { Button, useTranslation } from '@dxos/react-ui';
+import { Settings as SettingsForm } from '@dxos/react-ui-form';
+
+import { meta } from '#meta';
+import { NativeCapabilities, type Settings, type Update } from '#types';
+
+export type NativeSettingsProps = AppSurface.SettingsArticleProps<Settings.Settings>;
+
+type Pending = null | 'check' | 'install' | 'relaunch';
+
+type UpdateActions = {
+  onCheck: () => Promise<void>;
+  onInstall: () => Promise<void>;
+  onRelaunch: () => Promise<void>;
+};
+
+type UpdateRow = { description: string; button: ReactNode };
+
+export const NativeSettings = (_props: NativeSettingsProps) => {
+  const { t } = useTranslation(meta.id);
+  const manager = useCapability(NativeCapabilities.UpdateManager);
+  const status = useAtomValue(manager.status);
+
+  // UI-level pending flag. The status atom can flip between `checking` and `up-to-date` faster
+  // than the user can perceive, so we also gate the button on the click handler's lifetime to
+  // guarantee no duplicate triggers and a visible busy state.
+  const [pending, setPending] = useState<Pending>(null);
+
+  const runAction = (kind: Exclude<Pending, null>, action: () => Promise<void>) => async () => {
+    setPending(kind);
+    try {
+      await action();
+    } finally {
+      setPending(null);
+    }
+  };
+
+  const { description, button } = renderUpdateRow(status, pending, t, {
+    onCheck: runAction('check', manager.check),
+    onInstall: runAction('install', manager.install),
+    onRelaunch: runAction('relaunch', manager.relaunch),
+  });
+
+  return (
+    <SettingsForm.Viewport>
+      <SettingsForm.Section title={t('settings.title')}>
+        <SettingsForm.Item title={t('settings.updates.label')} description={description}>
+          {button}
+        </SettingsForm.Item>
+      </SettingsForm.Section>
+    </SettingsForm.Viewport>
+  );
+};
+
+const renderUpdateRow = (
+  status: Update.Status,
+  pending: Pending,
+  t: (key: string, options?: Record<string, unknown>) => string,
+  { onCheck, onInstall, onRelaunch }: UpdateActions,
+): UpdateRow => {
+  const isChecking = pending === 'check' || status.kind === 'checking';
+  const isInstalling = pending === 'install' || status.kind === 'downloading';
+
+  const checkButton = (disabled = false) => (
+    <Button disabled={disabled || isChecking || isInstalling || pending === 'relaunch'} onClick={() => void onCheck()}>
+      {isChecking ? t('settings.updates.checking.label') : t('settings.updates.check.label')}
+    </Button>
+  );
+
+  return Match.value(status).pipe(
+    Match.withReturnType<UpdateRow>(),
+    Match.when({ kind: 'unsupported' }, () => ({
+      description: t('settings.updates.unsupported.message'),
+      button: checkButton(true),
+    })),
+    Match.when({ kind: 'idle' }, () => ({
+      description: isChecking ? t('settings.updates.checking.message') : t('settings.updates.idle.message'),
+      button: checkButton(),
+    })),
+    Match.when({ kind: 'checking' }, () => ({
+      description: t('settings.updates.checking.message'),
+      button: checkButton(),
+    })),
+    Match.when({ kind: 'up-to-date' }, (s) => ({
+      description: isChecking
+        ? t('settings.updates.checking.message')
+        : t('settings.updates.up-to-date.message', {
+            checkedAt: formatDistanceToNow(new Date(s.checkedAt), { addSuffix: true }),
+          }),
+      button: checkButton(),
+    })),
+    Match.when({ kind: 'available' }, (s) => ({
+      description: t('settings.updates.available.message', { version: s.version }),
+      button: (
+        <Button variant='primary' disabled={isInstalling} onClick={() => void onInstall()}>
+          {isInstalling ? t('settings.updates.downloading.label') : t('settings.updates.update-now.label')}
+        </Button>
+      ),
+    })),
+    Match.when({ kind: 'downloading' }, (s) => {
+      const percent = s.contentLength > 0 ? Math.round((s.downloaded / s.contentLength) * 100) : 0;
+      return {
+        description: t('settings.updates.downloading.message', { percent }),
+        button: <Button disabled>{t('settings.updates.downloading.label')}</Button>,
+      };
+    }),
+    Match.when({ kind: 'ready' }, () => ({
+      description: t('settings.updates.ready.message'),
+      button: (
+        <Button variant='primary' disabled={pending === 'relaunch'} onClick={() => void onRelaunch()}>
+          {t('settings.updates.relaunch.label')}
+        </Button>
+      ),
+    })),
+    Match.when({ kind: 'failed' }, (s) => ({
+      description: t('settings.updates.failed.message', { error: s.error }),
+      button: checkButton(),
+    })),
+    Match.exhaustive,
+  );
+};

package/src/components/NativeSettings/index.ts

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

package/src/components/index.ts

@@ -0,0 +1,7 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { type ComponentType, lazy } from 'react';
+
+export const NativeSettings: ComponentType<any> = lazy(() => import('./NativeSettings'));

package/src/meta.ts

@@ -2,15 +2,31 @@
 // Copyright 2023 DXOS.org
 //
 
-import { type Plugin } from '@dxos/app-framework';
+import { Plugin } from '@dxos/app-framework';
+import { DXN } from '@dxos/keys';
 import { trim } from '@dxos/util';
 
-export const meta: Plugin.Meta = {
-  id: 'org.dxos.plugin.native',
-  name: 'Native',
+// TODO(wittjosiah): Rename plugin (package + id) from `native` to `app` to match the user-facing name.
+export const meta = Plugin.makeMeta({
+  key: DXN.make('org.dxos.plugin.native'),
+  name: 'App',
+  author: 'DXOS',
+  spec: 'PLUGIN.mdl',
   description: trim`
-    Native platform integration providing desktop-specific features and system-level capabilities.
-    Access native file dialogs, notifications, and OS integrations.
+    Tauri-based native platform integration for DXOS Composer on macOS, Linux, and Windows.
+
+    Provides Spotlight window integration that forwards spotlight:invoke Tauri events to
+    Composer operations, letting the OS-level launcher open spaces and switch workspaces
+    without the main window being focused first.
+
+    Manages over-the-air application updates via the Tauri updater plugin, automatically
+    checking for new releases in the background, streaming download progress, and surfacing
+    a toast notification with a one-click Relaunch action when an update is ready.
+
+    Spawns an Ollama sidecar process on localhost for local AI model inference, registering
+    it as an AiModelResolver so Assistant features can resolve model requests without any
+    external server dependency.
   `,
+  icon: 'ph--app-window--regular',
   tags: ['system'],
-};
+});