@dxos/plugin-native 0.9.0 → 0.9.1-staging.ee54ba693a

package/dx.config.ts

@@ -0,0 +1,32 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Config2 } from '@dxos/app-framework/config';
+import { trim } from '@dxos/util';
+
+export default Config2.make({
+  plugin: {
+    key: 'org.dxos.plugin.native',
+    name: 'App',
+    author: 'DXOS',
+    description: trim`
+      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.
+    `,
+    spec: 'PLUGIN.mdl',
+    icon: { key: 'ph--app-window--regular' },
+    tags: ['system'],
+  },
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dxos/plugin-native",
-  "version": "0.9.0",
+  "version": "0.9.1-staging.ee54ba693a",
   "description": "Composer plugin that runs when on a native device.",
   "homepage": "https://dxos.org",
   "bugs": "https://github.com/dxos/dxos/issues",
@@ -18,10 +18,10 @@
       "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"
+    "#containers": {
+      "source": "./src/containers/index.ts",
+      "types": "./dist/types/src/containers/index.d.ts",
+      "default": "./dist/lib/neutral/containers/index.mjs"
     },
     "#meta": {
       "source": "./src/meta.ts",
@@ -65,41 +65,42 @@
   "types": "dist/types/src/index.d.ts",
   "files": [
     "dist",
+    "dx.config.ts",
     "src",
     "PLUGIN.mdl"
   ],
   "dependencies": {
     "@effect-atom/atom-react": "^0.5.0",
-    "@effect/platform": "0.96.1",
+    "@effect/platform": "0.96.2",
     "@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/app-framework": "0.9.0",
-    "@dxos/effect": "0.9.0",
-    "@dxos/keys": "0.9.0",
-    "@dxos/ai": "0.9.0",
-    "@dxos/app-toolkit": "0.9.0",
-    "@dxos/log": "0.9.0",
-    "@dxos/plugin-assistant": "0.9.0",
-    "@dxos/util": "0.9.0"
+    "@dxos/ai": "0.9.1-staging.ee54ba693a",
+    "@dxos/app-toolkit": "0.9.1-staging.ee54ba693a",
+    "@dxos/effect": "0.9.1-staging.ee54ba693a",
+    "@dxos/keys": "0.9.1-staging.ee54ba693a",
+    "@dxos/app-framework": "0.9.1-staging.ee54ba693a",
+    "@dxos/plugin-assistant": "0.9.1-staging.ee54ba693a",
+    "@dxos/log": "0.9.1-staging.ee54ba693a",
+    "@dxos/util": "0.9.1-staging.ee54ba693a"
   },
   "devDependencies": {
-    "@types/react": "~19.2.7",
-    "effect": "3.21.3",
-    "react": "~19.2.3",
+    "@types/react": "~19.2.17",
+    "effect": "3.21.4",
+    "react": "~19.2.7",
     "vite": "^8.0.16",
-    "@dxos/react-ui-form": "0.9.0",
-    "@dxos/plugin-testing": "0.9.0",
-    "@dxos/react-ui": "0.9.0"
+    "@dxos/plugin-testing": "0.9.1-staging.ee54ba693a",
+    "@dxos/react-ui": "0.9.1-staging.ee54ba693a",
+    "@dxos/react-ui-form": "0.9.1-staging.ee54ba693a"
   },
   "peerDependencies": {
-    "effect": "3.21.3",
-    "react": "~19.2.3",
-    "@dxos/react-ui": "0.9.0",
-    "@dxos/react-ui-form": "0.9.0"
+    "effect": "3.21.4",
+    "react": "~19.2.7",
+    "@dxos/react-ui": "0.9.1-staging.ee54ba693a",
+    "@dxos/react-ui-form": "0.9.1-staging.ee54ba693a"
   },
   "publishConfig": {
     "access": "public"

package/src/NativePlugin.tsx

@@ -33,7 +33,7 @@ export const NativePlugin = Plugin.define(meta).pipe(
     activate: Ollama,
   }),
   AppPlugin.addPluginAssetModule({
-    asset: { pluginId: meta.id, path: 'PLUGIN.mdl', content: pluginSpec, mimeType: 'application/x-mdl' },
+    asset: { pluginId: meta.profile.key, path: 'PLUGIN.mdl', content: pluginSpec, mimeType: 'application/x-mdl' },
   }),
   Plugin.make,
 );

package/src/capabilities/ollama.ts

@@ -2,27 +2,40 @@
 // Copyright 2025 DXOS.org
 //
 
+import { Atom } from '@effect-atom/atom-react';
 import * as FetchHttpClient from '@effect/platform/FetchHttpClient';
 import * as HttpClient from '@effect/platform/HttpClient';
 import { Command } from '@tauri-apps/plugin-shell';
+import * as Cause from 'effect/Cause';
 import * as Context from 'effect/Context';
+import * as Duration from 'effect/Duration';
 import * as Effect from 'effect/Effect';
+import * as Either from 'effect/Either';
+import * as Exit from 'effect/Exit';
+import * as Fiber from 'effect/Fiber';
 import * as Layer from 'effect/Layer';
 import * as ManagedRuntime from 'effect/ManagedRuntime';
+import * as Schedule from 'effect/Schedule';
+import * as Stream from 'effect/Stream';
 
-import { type AiModelResolver } from '@dxos/ai';
-import { OllamaResolver } from '@dxos/ai/resolvers';
-import { Capability } from '@dxos/app-framework';
+import { type AiModelResolver, Provider } from '@dxos/ai';
+import { OllamaAdmin, OllamaResolver } from '@dxos/ai/resolvers';
+import { Capabilities, Capability } from '@dxos/app-framework';
 import { AppCapabilities } from '@dxos/app-toolkit';
 import { log } from '@dxos/log';
+import { AssistantCapabilities, type Ollama } from '@dxos/plugin-assistant';
 
 // NOTE: Running ollama on non-standard port (config Tauri).
 const OLLAMA_HOST = 'http://localhost:21434';
 
-export type OllamaCapabilities = Capability.Capability<typeof AppCapabilities.AiModelResolver>;
+export type OllamaCapabilities =
+  | Capability.Capability<typeof AppCapabilities.AiModelResolver>
+  | Capability.Capability<typeof AssistantCapabilities.OllamaManager>;
+
+export default Capability.makeModule(
+  Effect.fnUntraced(function* () {
+    const registry = yield* Capability.get(Capabilities.AtomRegistry);
 
-export default Capability.makeModule<[], OllamaCapabilities>(() =>
-  Effect.sync(() => {
     const runtime = ManagedRuntime.make(OllamaSidecar.layerLive);
 
     // Layer for the sidecar but the lifecycle is managed by the runtime.
@@ -30,11 +43,232 @@ export default Capability.makeModule<[], OllamaCapabilities>(() =>
       runtime.runtimeEffect.pipe(Effect.map((rt) => rt.context.pipe(Context.pick(OllamaSidecar)))),
     );
 
-    return Capability.contributes(
-      AppCapabilities.AiModelResolver,
-      OllamaSidecarModelResolver.pipe(Layer.provide(sidecarLayer)),
-      () => Effect.tryPromise(() => runtime.dispose()),
-    );
+    const admin = OllamaAdmin.make({ endpoint: OLLAMA_HOST });
+    const stateAtom = Atom.make<Ollama.ModelsState>({
+      kind: 'idle',
+      models: [],
+      loaded: [],
+      pulls: {},
+      errors: {},
+    }).pipe(Atom.keepAlive);
+
+    // Read/update the reactive state atom as Effects.
+    const getState = Effect.sync(() => registry.get(stateAtom));
+    const updateState = (f: (state: Ollama.ModelsState) => Ollama.ModelsState): Effect.Effect<void> =>
+      Effect.sync(() => registry.set(stateAtom, f(registry.get(stateAtom))));
+
+    // Connection-level failure (reaching the service); shown at the section, not tied to a model.
+    const fail = (error: string): Effect.Effect<void> => updateState((state) => ({ ...state, kind: 'failed', error }));
+
+    // Per-model action error (load/unload/remove/pull); shown inline on that model's row. Pass
+    // `undefined` to clear.
+    const setError = (name: string, error: string | undefined): Effect.Effect<void> =>
+      updateState((state) => {
+        const errors = { ...state.errors };
+        if (error) {
+          errors[name] = error;
+        } else {
+          delete errors[name];
+        }
+        return { ...state, errors };
+      });
+
+    // Write (or clear, when `progress` is undefined) the in-flight progress for `name`.
+    const setProgress = (name: string, progress: OllamaAdmin.PullProgress | undefined): Effect.Effect<void> =>
+      updateState((state) => {
+        const pulls = { ...state.pulls };
+        if (progress) {
+          pulls[name] = progress;
+        } else {
+          delete pulls[name];
+        }
+        return { ...state, pulls };
+      });
+
+    // Force the scoped sidecar layer, spawning the process idempotently — the runtime is lazy and
+    // only spawns on first force, so opening settings starts Ollama rather than hitting a refused
+    // connection, and a chat already using the resolver does not spawn a second process. The endpoint
+    // is unused; forcing `OllamaSidecar` is what triggers the spawn. Failures surface as defects.
+    const ensureRunning: Effect.Effect<void> = Effect.asVoid(OllamaSidecar).pipe(Effect.provide(sidecarLayer));
+
+    // Run an admin effect with the HttpClient provided, folding its typed failure into an Either so
+    // callers branch on the result without a typed error channel.
+    const runAdmin = <A, E extends { readonly message: string }>(
+      effect: Effect.Effect<A, E, HttpClient.HttpClient>,
+    ): Effect.Effect<Either.Either<A, string>> =>
+      effect.pipe(Effect.provide(clientLayer), Effect.either, Effect.map(Either.mapLeft((error) => error.message)));
+
+    // In-flight pull fibers, so a pull can be cancelled via interruption.
+    const pullFibers = new Map<string, Fiber.RuntimeFiber<void>>();
+
+    // Refresh only the loaded-into-memory set (cheap; no spawn). Logs load/unload transitions so the
+    // console reflects which model is resident when a chat request triggers a load.
+    const refreshLoaded: Effect.Effect<void> = Effect.gen(function* () {
+      const result = yield* runAdmin(admin.ps);
+      if (Either.isLeft(result)) {
+        return;
+      }
+      const before = (yield* getState).loaded.map((model) => model.name);
+      const after = result.right.map((model) => model.name);
+      if (before.join() !== after.join()) {
+        yield* Effect.sync(() => log.info('ollama loaded models changed', { loaded: after }));
+      }
+      yield* updateState((state) => ({ ...state, loaded: result.right }));
+    });
+
+    const refresh: Effect.Effect<void> = Effect.gen(function* () {
+      yield* updateState((state) => ({ ...state, kind: 'loading', error: undefined }));
+      const started = yield* Effect.exit(ensureRunning);
+      if (Exit.isFailure(started)) {
+        return yield* fail(formatError(Cause.squash(started.cause)));
+      }
+      // The sidecar process spawns before its HTTP server is listening, so retry until the first
+      // `list` succeeds rather than reporting a spurious failure on startup.
+      const result = yield* runAdmin(
+        admin.list.pipe(Effect.retry({ schedule: Schedule.spaced(Duration.millis(300)), times: 29 })),
+      );
+      if (Either.isLeft(result)) {
+        return yield* fail(result.left);
+      }
+      yield* updateState((state) => ({ ...state, kind: 'ready', models: result.right, error: undefined }));
+      yield* Effect.sync(() => log.info('ollama models', { installed: result.right.map((model) => model.name) }));
+      yield* refreshLoaded;
+    });
+
+    const pull = (name: string): Effect.Effect<void> =>
+      Effect.gen(function* () {
+        const started = yield* Effect.exit(ensureRunning);
+        if (Exit.isFailure(started)) {
+          return yield* fail(formatError(Cause.squash(started.cause)));
+        }
+        yield* setError(name, undefined);
+        yield* Effect.sync(() => log.info('ollama pull started', { name }));
+        yield* setProgress(name, { status: 'starting' });
+
+        // Ollama reports `completed`/`total` per layer (digest); aggregate across layers so the
+        // overall percent is monotonic rather than resetting to 0 as each layer starts.
+        const downloaded = new Map<string, { completed: number; total: number }>();
+        const onProgress = (progress: OllamaAdmin.PullProgress): Effect.Effect<void> =>
+          Effect.suspend(() => {
+            if (progress.digest && progress.total) {
+              downloaded.set(progress.digest, { completed: progress.completed ?? 0, total: progress.total });
+              let completed = 0;
+              let total = 0;
+              for (const layer of downloaded.values()) {
+                completed += layer.completed;
+                total += layer.total;
+              }
+              return setProgress(name, { status: progress.status, completed, total });
+            }
+            // Non-download phase (manifest, verifying, writing): keep the status label, drop totals.
+            return setProgress(name, { status: progress.status });
+          });
+
+        // Run the pull on a daemon fiber so `cancel` can interrupt it; clear progress and drop the
+        // fiber on every exit path. A cancelled pull interrupts the fiber — treated as a no-op.
+        const work = admin.pull(name).pipe(
+          Stream.runForEach(onProgress),
+          Effect.provide(clientLayer),
+          Effect.matchCauseEffect({
+            onFailure: (cause) =>
+              Cause.isInterruptedOnly(cause)
+                ? Effect.sync(() => log.info('ollama pull finished', { name, cancelled: true }))
+                : Effect.gen(function* () {
+                    const message = formatError(Cause.squash(cause));
+                    yield* Effect.sync(() => log.warn('ollama pull failed', { name, error: message }));
+                    yield* setError(name, message);
+                  }),
+            onSuccess: () =>
+              Effect.gen(function* () {
+                yield* Effect.sync(() => log.info('ollama pull finished', { name, cancelled: false }));
+                yield* refresh;
+              }),
+          }),
+          Effect.ensuring(setProgress(name, undefined)),
+          Effect.ensuring(Effect.sync(() => pullFibers.delete(name))),
+        );
+
+        const fiber = yield* Effect.forkDaemon(work);
+        yield* Effect.sync(() => pullFibers.set(name, fiber));
+      });
+
+    const cancel = (name: string): Effect.Effect<void> =>
+      Effect.gen(function* () {
+        yield* Effect.sync(() => log.info('ollama pull cancelled', { name }));
+        const fiber = pullFibers.get(name);
+        if (fiber) {
+          // The pull's `ensuring` clears progress and drops the fiber on interruption.
+          yield* Fiber.interrupt(fiber);
+        }
+      });
+
+    const load = (name: string): Effect.Effect<void> =>
+      Effect.gen(function* () {
+        yield* setError(name, undefined);
+        const started = yield* Effect.exit(ensureRunning);
+        if (Exit.isFailure(started)) {
+          return yield* setError(name, formatError(Cause.squash(started.cause)));
+        }
+        yield* Effect.sync(() => log.info('ollama load', { name }));
+        const result = yield* runAdmin(admin.load(name));
+        if (Either.isLeft(result)) {
+          yield* Effect.sync(() => log.warn('ollama load failed', { name, error: result.left }));
+          return yield* setError(name, result.left);
+        }
+        yield* refreshLoaded;
+      });
+
+    const unload = (name: string): Effect.Effect<void> =>
+      Effect.gen(function* () {
+        yield* setError(name, undefined);
+        const started = yield* Effect.exit(ensureRunning);
+        if (Exit.isFailure(started)) {
+          return yield* setError(name, formatError(Cause.squash(started.cause)));
+        }
+        yield* Effect.sync(() => log.info('ollama unload', { name }));
+        const result = yield* runAdmin(admin.unload(name));
+        if (Either.isLeft(result)) {
+          return yield* setError(name, result.left);
+        }
+        yield* refreshLoaded;
+      });
+
+    const remove = (name: string): Effect.Effect<void> =>
+      Effect.gen(function* () {
+        yield* setError(name, undefined);
+        const started = yield* Effect.exit(ensureRunning);
+        if (Exit.isFailure(started)) {
+          return yield* setError(name, formatError(Cause.squash(started.cause)));
+        }
+        const result = yield* runAdmin(admin.remove(name));
+        if (Either.isLeft(result)) {
+          return yield* setError(name, result.left);
+        }
+        yield* refresh;
+      });
+
+    const manager: Ollama.Manager = {
+      endpoint: OLLAMA_HOST,
+      state: stateAtom,
+      refresh,
+      refreshLoaded,
+      pull,
+      cancel,
+      load,
+      unload,
+      remove,
+    };
+
+    return [
+      // The runtime-dispose finalizer lives on the resolver contribution only; the manager closes
+      // over the same runtime, so there is a single disposal path.
+      Capability.contributes(
+        AppCapabilities.AiModelResolver,
+        OllamaSidecarModelResolver.pipe(Layer.provide(sidecarLayer)),
+        () => Effect.tryPromise(() => runtime.dispose()),
+      ),
+      Capability.contributes(AssistantCapabilities.OllamaManager, manager),
+    ];
   }),
 );
 
@@ -47,6 +281,9 @@ class OllamaSidecar extends Context.Tag('@dxos/plugin-native/OllamaSidecar')<
   static layerLive = Layer.scoped(
     OllamaSidecar,
     Effect.gen(function* () {
+      // The `ollama` launcher discovers `llama-server` + its libraries relative to its own
+      // executable (`<exe>/lib/ollama/`), ignoring OLLAMA_LIBRARY_PATH, so the runtime ships into
+      // `Contents/MacOS/lib/ollama` next to the signed sidecar (see tauri.conf bundle.macOS.files).
       const command = Command.sidecar('sidecar/ollama', ['serve'], {
         env: {
           OLLAMA_HOST,
@@ -54,11 +291,11 @@ class OllamaSidecar extends Context.Tag('@dxos/plugin-native/OllamaSidecar')<
         },
       });
 
-      // NOTE: Keeping those as console.log for consistent formatting.
-      // eslint-disable-next-line no-console
-      command.stdout.on('data', (data) => console.log('[ollama]', data.toString()));
-      // eslint-disable-next-line no-console
-      command.stderr.on('data', (data) => console.error('[ollama]', data.toString()));
+      // Ollama writes nearly all of its output (including normal startup/inference logs) to stderr,
+      // so route by the structured `level=` field rather than the stream to avoid flooding the
+      // console with red errors. Kept on `console.*` for Ollama's own line formatting.
+      command.stdout.on('data', (data) => logSidecar(data.toString()));
+      command.stderr.on('data', (data) => logSidecar(data.toString()));
       command.on('close', (code) => log.info('Ollama process exited', { code }));
       command.on('error', (error) => log.error('Ollama error', { error }));
       const child = yield* Effect.promise(() => command.spawn());
@@ -82,7 +319,35 @@ const OllamaSidecarModelResolver: Layer.Layer<AiModelResolver.AiModelResolver, n
       const { endpoint } = yield* OllamaSidecar;
       return OllamaResolver.make({
         endpoint,
+        provider: Provider.builtIn.id,
         transformClient: HttpClient.withTracerPropagation(false),
       });
     }),
   ).pipe(Layer.provide(FetchHttpClient.layer));
+
+const formatError = (error: unknown): string =>
+  typeof error === 'string' ? error : error instanceof Error ? error.message : String(error);
+
+/** Effect HttpClient layer shared by every admin call. */
+const clientLayer = FetchHttpClient.layer;
+
+/**
+ * Route a chunk of Ollama process output to the console by its structured log level. Ollama emits
+ * `INFO`/`WARN` to stderr alongside genuine errors, so only `level=ERROR` lines surface as errors.
+ */
+const logSidecar = (chunk: string): void => {
+  for (const line of chunk.split('\n')) {
+    if (line.trim().length === 0) {
+      continue;
+    }
+    /* eslint-disable no-console */
+    if (line.includes('level=ERROR')) {
+      console.error('[ollama]', line);
+    } else if (line.includes('level=WARN')) {
+      console.warn('[ollama]', line);
+    } else {
+      console.log('[ollama]', line);
+    }
+    /* eslint-enable no-console */
+  }
+};

package/src/capabilities/react-surface.tsx

@@ -9,7 +9,7 @@ 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 { NativeSettings } from '#containers';
 import { meta } from '#meta';
 import { type Settings } from '#types';
 
@@ -18,7 +18,7 @@ export default Capability.makeModule(() =>
     Capability.contributes(Capabilities.ReactSurface, [
       Surface.create({
         id: 'pluginSettings',
-        filter: AppSurface.settings(AppSurface.Article, meta.id),
+        filter: AppSurface.settings(AppSurface.Article, meta.profile.key),
         component: ({ data: { subject } }) => {
           const { settings, updateSettings } = useSettingsState<Settings.Settings>(subject.atom);
           return <NativeSettings settings={settings} onSettingsChange={updateSettings} />;

package/src/capabilities/settings.ts

@@ -14,7 +14,7 @@ import { NativeCapabilities, Settings } from '#types';
 export default Capability.makeModule(() =>
   Effect.sync(() => {
     const settingsAtom = createKvsStore({
-      key: meta.id,
+      key: meta.profile.key,
       schema: Settings.Settings,
       defaultValue: () => ({}),
     });
@@ -22,7 +22,7 @@ export default Capability.makeModule(() =>
     return [
       Capability.contributes(NativeCapabilities.Settings, settingsAtom),
       Capability.contributes(AppCapabilities.Settings, {
-        prefix: meta.id,
+        prefix: meta.profile.key,
         schema: Settings.Settings,
         atom: settingsAtom,
       }),

package/src/capabilities/updater.ts

@@ -167,12 +167,12 @@ export default Capability.makeModule(
         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 }],
+        id: `${meta.profile.key}.update-ready`,
+        title: ['update-ready.label', { ns: meta.profile.key }],
+        description: ['update-ready.description', { ns: meta.profile.key }],
         duration: Infinity,
-        actionLabel: ['update.label', { ns: meta.id }],
-        actionAlt: ['update.alt', { ns: meta.id }],
+        actionLabel: ['update.label', { ns: meta.profile.key }],
+        actionAlt: ['update.alt', { ns: meta.profile.key }],
         onAction: () => relaunch(),
       });
       return false;

package/src/{components → containers}/NativeSettings/NativeSettings.tsx

@@ -5,17 +5,18 @@
 import { useAtomValue } from '@effect-atom/atom-react';
 import { formatDistanceToNow } from 'date-fns/formatDistanceToNow';
 import * as Match from 'effect/Match';
+import * as Schema from 'effect/Schema';
 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 { Form } from '@dxos/react-ui-form';
 
 import { meta } from '#meta';
 import { NativeCapabilities, type Settings, type Update } from '#types';
 
-export type NativeSettingsProps = AppSurface.SettingsArticleProps<Settings.Settings>;
+export type NativeSettingsProps = AppSurface.SettingsProps<Settings.Settings>;
 
 type Pending = null | 'check' | 'install' | 'relaunch';
 
@@ -28,7 +29,7 @@ type UpdateActions = {
 type UpdateRow = { description: string; button: ReactNode };
 
 export const NativeSettings = (_props: NativeSettingsProps) => {
-  const { t } = useTranslation(meta.id);
+  const { t } = useTranslation(meta.profile.key);
   const manager = useCapability(NativeCapabilities.UpdateManager);
   const status = useAtomValue(manager.status);
 
@@ -53,13 +54,17 @@ export const NativeSettings = (_props: NativeSettingsProps) => {
   });
 
   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>
+    <Form.Root schema={Schema.Struct({})} values={{}} variant='settings'>
+      <Form.Viewport scroll>
+        <Form.Content>
+          <Form.Section title={meta.profile.name ?? meta.profile.key}>
+            <Form.Row label={t('settings.updates.label')} description={description}>
+              {button}
+            </Form.Row>
+          </Form.Section>
+        </Form.Content>
+      </Form.Viewport>
+    </Form.Root>
   );
 };
 

package/src/meta.ts

@@ -3,30 +3,8 @@
 //
 
 import { Plugin } from '@dxos/app-framework';
-import { DXN } from '@dxos/keys';
-import { trim } from '@dxos/util';
 
-// 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`
-    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.
+import config from '../dx.config';
 
-    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'],
-});
+// TODO(wittjosiah): Rename plugin (package + id) from `native` to `app` to match the user-facing name.
+export const meta = Plugin.getMetaFromConfig(config);

package/src/translations.ts

@@ -9,12 +9,11 @@ import { meta } from '#meta';
 export const translations = [
   {
     'en-US': {
-      [meta.id]: {
+      [meta.profile.key]: {
         'update-ready.label': 'Ready to update',
         'update-ready.description': 'A new version of Composer is available.',
         'update.label': 'Update',
         'update.alt': 'Relaunch the app to update',
-        'settings.title': 'App',
         'settings.updates.label': 'Updates',
         'settings.updates.check.label': 'Check for updates',
         'settings.updates.checking.label': 'Checking…',

package/src/types/NativeCapabilities.ts

@@ -12,5 +12,9 @@ import { meta } from '#meta';
 
 // Inline imports to avoid `Settings` / `Update` namespace aliases colliding with the
 // capability constants exported below.
-export const Settings = Capability.make<Atom.Writable<import('./Settings').Settings>>(`${meta.id}.capability.settings`);
-export const UpdateManager = Capability.make<import('./Update').Manager>(`${meta.id}.capability.update-manager`);
+export const Settings = Capability.make<Atom.Writable<import('./Settings').Settings>>(
+  `${meta.profile.key}.capability.settings`,
+);
+export const UpdateManager = Capability.make<import('./Update').Manager>(
+  `${meta.profile.key}.capability.update-manager`,
+);