@dxos/plugin-observability 0.8.4-main.84f28bd → 0.8.4-main.937b3ca

package/dist/types/src/types.d.ts

@@ -1,286 +0,0 @@
-import { Schema } from 'effect';
-import { Type } from '@dxos/echo';
-export declare const UserFeedback: Schema.Struct<{
-    message: Schema.filter<Schema.filter<typeof Schema.String>>;
-}>;
-export type UserFeedback = Schema.Schema.Type<typeof UserFeedback>;
-export declare namespace ObservabilityAction {
-    const Toggle_base: Schema.TaggedClass<Toggle, "dxos.org/plugin/observability/action/toggle", {
-        readonly _tag: Schema.tag<"dxos.org/plugin/observability/action/toggle">;
-    } & {
-        input: Schema.Struct<{
-            state: Schema.optional<typeof Schema.Boolean>;
-        }>;
-        output: typeof Schema.Boolean;
-    }>;
-    export class Toggle extends Toggle_base {
-    }
-    const CaptureUserFeedback_base: Schema.TaggedClass<CaptureUserFeedback, "dxos.org/plugin/observability/action/capture-feedback", {
-        readonly _tag: Schema.tag<"dxos.org/plugin/observability/action/capture-feedback">;
-    } & {
-        input: Schema.Struct<{
-            message: Schema.filter<Schema.filter<typeof Schema.String>>;
-        }>;
-        output: typeof Schema.Void;
-    }>;
-    export class CaptureUserFeedback extends CaptureUserFeedback_base {
-    }
-    const BaseSendEvent_base: Schema.TaggedClass<BaseSendEvent, "dxos.org/plugin/observability/action/send-event", {
-        readonly _tag: Schema.tag<"dxos.org/plugin/observability/action/send-event">;
-    } & {
-        input: Schema.Struct<{
-            name: typeof Schema.String;
-            properties: Schema.optional<typeof Schema.Object>;
-        }>;
-        output: typeof Schema.Void;
-    }>;
-    /** Base intent for sending events. */
-    export class BaseSendEvent extends BaseSendEvent_base {
-    }
-    const SendEvent_base: Schema.TaggedClass<SendEvent, "dxos.org/plugin/observability/action/send-event", {
-        readonly _tag: Schema.tag<"dxos.org/plugin/observability/action/send-event">;
-    } & {
-        input: Schema.Union<[Schema.Struct<{
-            name: Schema.Literal<["identity.create"]>;
-        }>, Schema.Struct<{
-            name: Schema.Literal<["identity.join"]>;
-        }>, Schema.Struct<{
-            name: Schema.Literal<["identity.recover"]>;
-        }>, Schema.Struct<{
-            name: Schema.Literal<["identity.share"]>;
-        }>, Schema.Struct<{
-            name: Schema.Literal<["navigation.activate"]>;
-            properties: Schema.Struct<{
-                subjectId: typeof Schema.String;
-                typename: Schema.optional<typeof Schema.String>;
-            }>;
-        }>, Schema.Struct<{
-            name: Schema.Literal<["page.load"]>;
-            properties: Schema.Struct<{
-                loadDuration: typeof Schema.Number;
-            }>;
-        }>, Schema.Struct<{
-            name: Schema.Literal<["plugins.toggle"]>;
-            properties: Schema.Struct<{
-                plugin: typeof Schema.String;
-                enabled: typeof Schema.Boolean;
-            }>;
-        }>, Schema.Struct<{
-            name: Schema.Literal<["space.create"]>;
-            properties: Schema.Struct<{
-                spaceId: Schema.Schema<Type.SpaceId, string, never> & {
-                    byteLength: number;
-                    encode: (value: Uint8Array) => Type.SpaceId;
-                    decode: (value: Type.SpaceId) => Uint8Array;
-                    isValid: (value: string) => value is Type.SpaceId;
-                    make: (value: string) => Type.SpaceId;
-                    random: () => Type.SpaceId;
-                };
-            }>;
-        }>, Schema.Struct<{
-            name: Schema.Literal<["space.join"]>;
-            properties: Schema.Struct<{
-                spaceId: Schema.Schema<Type.SpaceId, string, never> & {
-                    byteLength: number;
-                    encode: (value: Uint8Array) => Type.SpaceId;
-                    decode: (value: Type.SpaceId) => Uint8Array;
-                    isValid: (value: string) => value is Type.SpaceId;
-                    make: (value: string) => Type.SpaceId;
-                    random: () => Type.SpaceId;
-                };
-            }>;
-        }>, Schema.Struct<{
-            name: Schema.Literal<["space.limit"]>;
-            properties: Schema.Struct<{
-                spaceId: Schema.Schema<Type.SpaceId, string, never> & {
-                    byteLength: number;
-                    encode: (value: Uint8Array) => Type.SpaceId;
-                    decode: (value: Type.SpaceId) => Uint8Array;
-                    isValid: (value: string) => value is Type.SpaceId;
-                    make: (value: string) => Type.SpaceId;
-                    random: () => Type.SpaceId;
-                };
-            }>;
-        }>, Schema.Struct<{
-            name: Schema.Literal<["space.lock"]>;
-            properties: Schema.Struct<{
-                spaceId: Schema.Schema<Type.SpaceId, string, never> & {
-                    byteLength: number;
-                    encode: (value: Uint8Array) => Type.SpaceId;
-                    decode: (value: Type.SpaceId) => Uint8Array;
-                    isValid: (value: string) => value is Type.SpaceId;
-                    make: (value: string) => Type.SpaceId;
-                    random: () => Type.SpaceId;
-                };
-            }>;
-        }>, Schema.Struct<{
-            name: Schema.Literal<["space.migrate"]>;
-            properties: Schema.Struct<{
-                spaceId: Schema.Schema<Type.SpaceId, string, never> & {
-                    byteLength: number;
-                    encode: (value: Uint8Array) => Type.SpaceId;
-                    decode: (value: Type.SpaceId) => Uint8Array;
-                    isValid: (value: string) => value is Type.SpaceId;
-                    make: (value: string) => Type.SpaceId;
-                    random: () => Type.SpaceId;
-                };
-                targetVersion: Schema.optional<typeof Schema.String>;
-                version: Schema.optional<typeof Schema.String>;
-            }>;
-        }>, Schema.Struct<{
-            name: Schema.Literal<["space.object.add"]>;
-            properties: Schema.Struct<{
-                spaceId: Schema.Schema<Type.SpaceId, string, never> & {
-                    byteLength: number;
-                    encode: (value: Uint8Array) => Type.SpaceId;
-                    decode: (value: Type.SpaceId) => Uint8Array;
-                    isValid: (value: string) => value is Type.SpaceId;
-                    make: (value: string) => Type.SpaceId;
-                    random: () => Type.SpaceId;
-                };
-                objectId: typeof Schema.String;
-                typename: Schema.optional<typeof Schema.String>;
-            }>;
-        }>, Schema.Struct<{
-            name: Schema.Literal<["space.share"]>;
-            properties: Schema.Struct<{
-                spaceId: Schema.Schema<Type.SpaceId, string, never> & {
-                    byteLength: number;
-                    encode: (value: Uint8Array) => Type.SpaceId;
-                    decode: (value: Type.SpaceId) => Uint8Array;
-                    isValid: (value: string) => value is Type.SpaceId;
-                    make: (value: string) => Type.SpaceId;
-                    random: () => Type.SpaceId;
-                };
-            }>;
-        }>, Schema.Struct<{
-            name: Schema.Literal<["space.unlock"]>;
-            properties: Schema.Struct<{
-                spaceId: Schema.Schema<Type.SpaceId, string, never> & {
-                    byteLength: number;
-                    encode: (value: Uint8Array) => Type.SpaceId;
-                    decode: (value: Type.SpaceId) => Uint8Array;
-                    isValid: (value: string) => value is Type.SpaceId;
-                    make: (value: string) => Type.SpaceId;
-                    random: () => Type.SpaceId;
-                };
-            }>;
-        }>, Schema.Struct<{
-            name: Schema.Literal<["threads.create"]>;
-            properties: Schema.Struct<{
-                spaceId: Schema.Schema<Type.SpaceId, string, never> & {
-                    byteLength: number;
-                    encode: (value: Uint8Array) => Type.SpaceId;
-                    decode: (value: Type.SpaceId) => Uint8Array;
-                    isValid: (value: string) => value is Type.SpaceId;
-                    make: (value: string) => Type.SpaceId;
-                    random: () => Type.SpaceId;
-                };
-                threadId: typeof Schema.String;
-            }>;
-        }>, Schema.Struct<{
-            name: Schema.Literal<["threads.delete"]>;
-            properties: Schema.Struct<{
-                spaceId: Schema.Schema<Type.SpaceId, string, never> & {
-                    byteLength: number;
-                    encode: (value: Uint8Array) => Type.SpaceId;
-                    decode: (value: Type.SpaceId) => Uint8Array;
-                    isValid: (value: string) => value is Type.SpaceId;
-                    make: (value: string) => Type.SpaceId;
-                    random: () => Type.SpaceId;
-                };
-                threadId: typeof Schema.String;
-            }>;
-        }>, Schema.Struct<{
-            name: Schema.Literal<["threads.message.add"]>;
-            properties: Schema.Struct<{
-                spaceId: Schema.Schema<Type.SpaceId, string, never> & {
-                    byteLength: number;
-                    encode: (value: Uint8Array) => Type.SpaceId;
-                    decode: (value: Type.SpaceId) => Uint8Array;
-                    isValid: (value: string) => value is Type.SpaceId;
-                    make: (value: string) => Type.SpaceId;
-                    random: () => Type.SpaceId;
-                };
-                threadId: typeof Schema.String;
-                threadLength: typeof Schema.Number;
-                messageId: typeof Schema.String;
-                messageLength: typeof Schema.Number;
-            }>;
-        }>, Schema.Struct<{
-            name: Schema.Literal<["threads.message.delete"]>;
-            properties: Schema.Struct<{
-                spaceId: Schema.Schema<Type.SpaceId, string, never> & {
-                    byteLength: number;
-                    encode: (value: Uint8Array) => Type.SpaceId;
-                    decode: (value: Type.SpaceId) => Uint8Array;
-                    isValid: (value: string) => value is Type.SpaceId;
-                    make: (value: string) => Type.SpaceId;
-                    random: () => Type.SpaceId;
-                };
-                threadId: typeof Schema.String;
-                messageId: typeof Schema.String;
-            }>;
-        }>, Schema.Struct<{
-            name: Schema.Literal<["threads.message.undo-delete"]>;
-            properties: Schema.Struct<{
-                spaceId: Schema.Schema<Type.SpaceId, string, never> & {
-                    byteLength: number;
-                    encode: (value: Uint8Array) => Type.SpaceId;
-                    decode: (value: Type.SpaceId) => Uint8Array;
-                    isValid: (value: string) => value is Type.SpaceId;
-                    make: (value: string) => Type.SpaceId;
-                    random: () => Type.SpaceId;
-                };
-                threadId: typeof Schema.String;
-                messageId: typeof Schema.String;
-            }>;
-        }>, Schema.Struct<{
-            name: Schema.Literal<["threads.message.update"]>;
-            properties: Schema.Struct<{
-                spaceId: Schema.Schema<Type.SpaceId, string, never> & {
-                    byteLength: number;
-                    encode: (value: Uint8Array) => Type.SpaceId;
-                    decode: (value: Type.SpaceId) => Uint8Array;
-                    isValid: (value: string) => value is Type.SpaceId;
-                    make: (value: string) => Type.SpaceId;
-                    random: () => Type.SpaceId;
-                };
-                messageId: typeof Schema.String;
-                messageLength: typeof Schema.Number;
-            }>;
-        }>, Schema.Struct<{
-            name: Schema.Literal<["threads.toggle-resolved"]>;
-            properties: Schema.Struct<{
-                spaceId: Schema.Schema<Type.SpaceId, string, never> & {
-                    byteLength: number;
-                    encode: (value: Uint8Array) => Type.SpaceId;
-                    decode: (value: Type.SpaceId) => Uint8Array;
-                    isValid: (value: string) => value is Type.SpaceId;
-                    make: (value: string) => Type.SpaceId;
-                    random: () => Type.SpaceId;
-                };
-                threadId: typeof Schema.String;
-            }>;
-        }>, Schema.Struct<{
-            name: Schema.Literal<["threads.undo-delete"]>;
-            properties: Schema.Struct<{
-                spaceId: Schema.Schema<Type.SpaceId, string, never> & {
-                    byteLength: number;
-                    encode: (value: Uint8Array) => Type.SpaceId;
-                    decode: (value: Type.SpaceId) => Uint8Array;
-                    isValid: (value: string) => value is Type.SpaceId;
-                    make: (value: string) => Type.SpaceId;
-                    random: () => Type.SpaceId;
-                };
-                threadId: typeof Schema.String;
-            }>;
-        }>]>;
-        output: typeof Schema.Void;
-    }>;
-    /** Intent with strict types for first-party events. */
-    export class SendEvent extends SendEvent_base {
-    }
-    export {};
-}
-//# sourceMappingURL=types.d.ts.map

package/dist/types/src/types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/types.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAEhC,OAAO,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AAUlC,eAAO,MAAM,YAAY;;EAEvB,CAAC;AAEH,MAAM,MAAM,YAAY,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,YAAY,CAAC,CAAC;AAInE,yBAAiB,mBAAmB,CAAC;;;;;;;;;IACnC,MAAM,OAAO,MAAO,SAAQ,WAK1B;KAAG;;;;;;;;;IAEL,MAAM,OAAO,mBAAoB,SAAQ,wBAMxC;KAAG;;;;;;;;;;IAEJ,sCAAsC;IACtC,MAAM,OAAO,aAAc,SAAQ,kBAMjC;KAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAEL,uDAAuD;IACvD,MAAM,OAAO,SAAU,SAAQ,cAuJ7B;KAAG;;CACN"}

package/src/capabilities/app-graph-builder.ts

@@ -1,45 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { Rx } from '@effect-rx/rx-react';
-import { Option, pipe } from 'effect';
-
-import { Capabilities, contributes, type PluginContext } from '@dxos/app-framework';
-import { createExtension, ROOT_ID } from '@dxos/plugin-graph';
-
-import { OBSERVABILITY_PLUGIN } from '../meta';
-
-// NOTE: Copied from @dxos/plugin-deck to break circular dependency.
-const ATTENDABLE_PATH_SEPARATOR = '~';
-const DECK_COMPANION_TYPE = 'dxos.org/plugin/deck/deck-companion';
-
-export default (context: PluginContext) =>
-  contributes(Capabilities.AppGraphBuilder, [
-    createExtension({
-      id: `${OBSERVABILITY_PLUGIN}/help`,
-      connector: (node) =>
-        Rx.make((get) =>
-          pipe(
-            get(node),
-            Option.flatMap((node) => (node.id === ROOT_ID ? Option.some(node) : Option.none())),
-            Option.map((node) => {
-              return [
-                {
-                  id: [node.id, 'help'].join(ATTENDABLE_PATH_SEPARATOR),
-                  type: DECK_COMPANION_TYPE,
-                  data: null,
-                  properties: {
-                    label: ['help label', { ns: OBSERVABILITY_PLUGIN }],
-                    icon: 'ph--question--regular',
-                    disposition: 'hidden',
-                    position: 'hoist',
-                  },
-                },
-              ];
-            }),
-            Option.getOrElse(() => []),
-          ),
-        ),
-    }),
-  ]);

package/src/capabilities/capabilities.ts

@@ -1,22 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { defineCapability } from '@dxos/app-framework';
-import { type Client } from '@dxos/client';
-import { type Observability } from '@dxos/observability';
-
-import { OBSERVABILITY_PLUGIN } from '../meta';
-
-export namespace ObservabilityCapabilities {
-  export type State = {
-    group?: string;
-    notified?: boolean;
-  };
-  export const State = defineCapability<State>(`${OBSERVABILITY_PLUGIN}/capability/state`);
-
-  export const Observability = defineCapability<Observability>(`${OBSERVABILITY_PLUGIN}/capability/observability`);
-}
-
-// NOTE: This is cloned from the client plugin to avoid circular dependencies.
-export const ClientCapability = defineCapability<Client>('dxos.org/plugin/client/capability/client');

package/src/capabilities/client-ready.ts

@@ -1,97 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import {
-  Capabilities,
-  contributes,
-  createIntent,
-  LayoutAction,
-  SettingsAction,
-  type PluginContext,
-} from '@dxos/app-framework';
-import { setupTelemetryListeners, type Observability } from '@dxos/observability';
-
-import { ClientCapability, ObservabilityCapabilities } from './capabilities';
-import { OBSERVABILITY_PLUGIN } from '../meta';
-import { ObservabilityAction } from '../types';
-
-type ClientReadyOptions = {
-  context: PluginContext;
-  namespace: string;
-  observability: Observability;
-};
-
-export default async ({ context, namespace, observability }: ClientReadyOptions) => {
-  const manager = context.getCapability(Capabilities.PluginManager);
-  const { dispatchPromise: dispatch } = context.getCapability(Capabilities.IntentDispatcher);
-  const state = context.getCapability(ObservabilityCapabilities.State);
-  const client = context.getCapability(ClientCapability);
-
-  const sendPrivacyNotice = async () => {
-    const environment = client?.config?.values.runtime?.app?.env?.DX_ENVIRONMENT;
-    const notify =
-      environment && environment !== 'ci' && !environment.endsWith('.local') && !environment.endsWith('.lan');
-    if (!state.notified && notify) {
-      await dispatch(
-        createIntent(LayoutAction.AddToast, {
-          part: 'toast',
-          subject: {
-            id: `${OBSERVABILITY_PLUGIN}/notice`,
-            title: ['observability toast label', { ns: OBSERVABILITY_PLUGIN }],
-            description: ['observability toast description', { ns: OBSERVABILITY_PLUGIN }],
-            duration: Infinity,
-            icon: 'ph--info--regular',
-            actionLabel: ['observability toast action label', { ns: OBSERVABILITY_PLUGIN }],
-            actionAlt: ['observability toast action alt', { ns: OBSERVABILITY_PLUGIN }],
-            closeLabel: ['observability toast close label', { ns: OBSERVABILITY_PLUGIN }],
-            onAction: () => dispatch(createIntent(SettingsAction.Open, { plugin: OBSERVABILITY_PLUGIN })),
-          },
-        }),
-      );
-
-      state.notified = true;
-    }
-  };
-
-  // Ensure errors are tagged with enabled plugins to help with reproductions.
-  manager.enabled.map((plugin) => observability?.setTag(`pluginEnabled-${plugin}`, 'true', 'errors'));
-
-  await dispatch(
-    createIntent(ObservabilityAction.SendEvent, {
-      name: 'page.load',
-      properties: {
-        // TODO(wittjosiah): These apis are deprecated. Is there a better way to find this information?
-        loadDuration: window.performance.timing.loadEventEnd - window.performance.timing.loadEventStart,
-      },
-    }),
-  );
-
-  // Start client observability (i.e. not running as shared worker)
-  // TODO(nf): how to prevent multiple instances for single shared worker?
-  const cleanup = setupTelemetryListeners(namespace, client, observability);
-
-  await Promise.all([
-    observability.setIdentityTags(client.services.services),
-    observability.startRuntimeMetrics(client),
-    observability.startNetworkMetrics(client.services.services),
-    observability.startSpacesMetrics(client, namespace),
-  ]);
-
-  if (client.halo.identity.get()) {
-    await sendPrivacyNotice();
-  } else {
-    const subscription = client.halo.identity.subscribe(async (identity) => {
-      if (identity && observability) {
-        await sendPrivacyNotice();
-        await observability.setIdentityTags(client.services.services);
-        subscription.unsubscribe();
-      }
-    });
-  }
-
-  return contributes(ObservabilityCapabilities.Observability, observability, async () => {
-    cleanup();
-    await observability.close();
-  });
-};

package/src/capabilities/intent-resolver.ts

@@ -1,68 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { Capabilities, contributes, createResolver, IntentAction, type PluginContext } from '@dxos/app-framework';
-import { log } from '@dxos/log';
-import { getTelemetryIdentity, storeObservabilityDisabled } from '@dxos/observability';
-
-import { ClientCapability, ObservabilityCapabilities } from './capabilities';
-import { type ObservabilitySettingsProps } from '../components';
-import { OBSERVABILITY_PLUGIN } from '../meta';
-import { ObservabilityAction } from '../types';
-
-export default ({ context, namespace }: { context: PluginContext; namespace: string }) =>
-  contributes(Capabilities.IntentResolver, [
-    createResolver({
-      intent: IntentAction.Track,
-      resolve: (intent) => {
-        log.info('intent', { intent });
-      },
-    }),
-    createResolver({
-      intent: ObservabilityAction.Toggle,
-      resolve: async ({ state }) => {
-        const client = context.getCapability(ClientCapability);
-        const observability = context.getCapability(ObservabilityCapabilities.Observability);
-        const settings = context
-          .getCapability(Capabilities.SettingsStore)
-          .getStore<ObservabilitySettingsProps>(OBSERVABILITY_PLUGIN)!.value;
-        settings.enabled = state ?? !settings.enabled;
-        observability.track({
-          ...getTelemetryIdentity(client),
-          action: 'observability.toggle',
-          properties: {
-            enabled: settings.enabled,
-          },
-        });
-        observability.setMode(settings.enabled ? 'basic' : 'disabled');
-        await storeObservabilityDisabled(namespace, !settings.enabled);
-        return { data: settings.enabled };
-      },
-    }),
-    createResolver({
-      intent: ObservabilityAction.SendEvent,
-      resolve: (data) => {
-        const client = context.getCapability(ClientCapability);
-        const properties = 'properties' in data ? data.properties : {};
-
-        // NOTE: This is to ensure that events fired before observability is ready are still sent.
-        // TODO(wittjosiah): If the intent dispatcher supports concurrent actions in the future,
-        //   then this could be awaited still rather than voiding.
-        void context.waitForCapability(ObservabilityCapabilities.Observability).then((observability) => {
-          observability.track({
-            ...getTelemetryIdentity(client),
-            action: data.name,
-            properties,
-          });
-        });
-      },
-    }),
-    createResolver({
-      intent: ObservabilityAction.CaptureUserFeedback,
-      resolve: async (data) => {
-        const observability = context.getCapability(ObservabilityCapabilities.Observability);
-        observability.captureUserFeedback(data.message);
-      },
-    }),
-  ]);

package/src/capabilities/react-surface.tsx

@@ -1,27 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import React from 'react';
-
-import { contributes, Capabilities, createSurface } from '@dxos/app-framework';
-import { SettingsStore } from '@dxos/local-storage';
-
-import { HelpContainer, ObservabilitySettings, type ObservabilitySettingsProps } from '../components';
-import { OBSERVABILITY_PLUGIN } from '../meta';
-
-export default () =>
-  contributes(Capabilities.ReactSurface, [
-    createSurface({
-      id: OBSERVABILITY_PLUGIN,
-      role: 'article',
-      filter: (data): data is { subject: SettingsStore<ObservabilitySettingsProps> } =>
-        data.subject instanceof SettingsStore && data.subject.prefix === OBSERVABILITY_PLUGIN,
-      component: ({ data: { subject } }) => <ObservabilitySettings settings={subject.value} />,
-    }),
-    createSurface({
-      id: `${OBSERVABILITY_PLUGIN}/help`,
-      role: 'deck-companion--help',
-      component: () => <HelpContainer />,
-    }),
-  ]);

package/src/capabilities/settings.ts

@@ -1,21 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { Capabilities, contributes } from '@dxos/app-framework';
-import { live } from '@dxos/live-object';
-
-import { type ObservabilitySettingsProps, ObservabilitySettingsSchema } from '../components';
-import { meta } from '../meta';
-
-export default () => {
-  const settings = live<ObservabilitySettingsProps>({
-    enabled: true,
-  });
-
-  return contributes(Capabilities.Settings, {
-    prefix: meta.id,
-    schema: ObservabilitySettingsSchema,
-    value: settings,
-  });
-};

package/src/capabilities/state.ts

@@ -1,21 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { contributes } from '@dxos/app-framework';
-import { LocalStorageStore } from '@dxos/local-storage';
-import { getObservabilityGroup } from '@dxos/observability';
-
-import { ObservabilityCapabilities } from './capabilities';
-import { OBSERVABILITY_PLUGIN } from '../meta';
-
-export default async ({ namespace }: { namespace: string }) => {
-  const state = new LocalStorageStore<ObservabilityCapabilities.State>(OBSERVABILITY_PLUGIN);
-
-  state.prop({ key: 'notified', type: LocalStorageStore.bool({ allowUndefined: true }) });
-
-  // NOTE: This is not stored in local storage such that it can be accessed by workers.
-  state.values.group = await getObservabilityGroup(namespace);
-
-  return contributes(ObservabilityCapabilities.State, state.values, () => state.close());
-};

package/src/events.ts

@@ -1,14 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { defineEvent, Events } from '@dxos/app-framework';
-
-import { OBSERVABILITY_PLUGIN } from './meta';
-
-export namespace ObservabilityEvents {
-  export const StateReady = Events.createStateEvent(OBSERVABILITY_PLUGIN);
-}
-
-// NOTE: This is cloned from the client plugin to avoid circular dependencies.
-export const ClientReadyEvent = defineEvent('dxos.org/plugin/client/event/client-ready');