@dxos/plugin-debug 0.8.4-main.72ec0f3 → 0.8.4-main.7996785055

package/src/capabilities/index.ts

@@ -2,9 +2,7 @@
 // Copyright 2025 DXOS.org
 //
 
-import { lazy } from '@dxos/app-framework';
-
-export const AppGraphBuilder = lazy(() => import('./app-graph-builder'));
-export const ReactContext = lazy(() => import('./react-context'));
-export const ReactSurface = lazy(() => import('./react-surface'));
-export const DebugSettings = lazy(() => import('./settings'));
+export * from './app-graph-builder';
+export * from './react-context';
+export * from './react-surface';
+export * from './settings';

package/src/capabilities/react-context/index.ts

@@ -0,0 +1,7 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Capability } from '@dxos/app-framework';
+
+export const ReactContext = Capability.lazy('ReactContext', () => import('./react-context'));

package/src/capabilities/react-context/react-context.tsx

@@ -0,0 +1,25 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+import React from 'react';
+
+import { Capabilities, Capability } from '@dxos/app-framework';
+import { Surface } from '@dxos/app-framework/ui';
+import { DevtoolsContextProvider } from '@dxos/devtools';
+
+import { meta } from '../../meta';
+
+export default Capability.makeModule(() =>
+  Effect.succeed(
+    Capability.contributes(Capabilities.ReactContext, {
+      id: meta.id,
+      context: ({ children }) => (
+        <Surface.ProfilerProvider>
+          <DevtoolsContextProvider>{children}</DevtoolsContextProvider>
+        </Surface.ProfilerProvider>
+      ),
+    }),
+  ),
+);

package/src/capabilities/react-surface/index.ts

@@ -0,0 +1,7 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Capability } from '@dxos/app-framework';
+
+export const ReactSurface = Capability.lazy('ReactSurface', () => import('./react-surface'));

package/src/capabilities/react-surface/react-surface.tsx

@@ -0,0 +1,414 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+import React, { useCallback } from 'react';
+
+import { Capabilities, Capability } from '@dxos/app-framework';
+import { Surface, useOperationInvoker, useSettingsState } from '@dxos/app-framework/ui';
+import { AppCapabilities, LayoutOperation, getObjectPathFromObject } from '@dxos/app-toolkit';
+
+import {
+  AutomergePanel,
+  ConfigPanel,
+  CredentialsPanel,
+  DeviceListPanel,
+  DiagnosticsPanel,
+  EdgeDashboardPanel,
+  FeedsPanel,
+  IdentityPanel,
+  InvocationTraceContainer,
+  KeyringPanel,
+  LoggingPanel,
+  MembersPanel,
+  MetadataPanel,
+  NetworkPanel,
+  ObjectsPanel,
+  QueuesPanel,
+  SchemaPanel,
+  SignalPanel,
+  SpaceInfoPanel,
+  SpaceListPanel,
+  StoragePanel,
+  SwarmPanel,
+  TestingPanel,
+  TracingPanel,
+  WorkflowPanel,
+} from '@dxos/devtools';
+import { Obj } from '@dxos/echo';
+import { Collection } from '@dxos/echo';
+import { type LogBuffer } from '@dxos/log';
+import { log } from '@dxos/log';
+
+import { type Graph } from '@dxos/plugin-graph';
+import { ScriptOperation } from '@dxos/plugin-script/operations';
+import { SpaceOperation } from '@dxos/plugin-space/operations';
+import { useActiveSpace } from '@dxos/plugin-space';
+import { type Space, SpaceState, isSpace } from '@dxos/react-client/echo';
+import { Panel } from '@dxos/react-ui';
+
+import {
+  DebugGraph,
+  DebugObjectPanel,
+  DebugSettings,
+  DebugSpaceObjectsPanel,
+  DebugStatus,
+  DevtoolsOverviewContainer,
+  SpaceGenerator,
+  Wireframe,
+} from '../../containers';
+import { meta } from '../../meta';
+import { DebugCapabilities, type DebugSettingsProps, Devtools } from '../../types';
+
+type SpaceDebug = {
+  type: string;
+  space: Space;
+};
+
+type GraphDebug = {
+  graph: Graph.Graph;
+  root: string;
+};
+
+const isSpaceDebug = (data: any): data is SpaceDebug => data?.type === `${meta.id}.space` && isSpace(data.space);
+const isGraphDebug = (data: any): data is GraphDebug => {
+  const graph = data?.graph;
+  return (
+    graph != null && typeof graph === 'object' && typeof graph.json === 'function' && typeof data?.root === 'string'
+  );
+};
+
+const useCurrentSpace = useActiveSpace;
+
+type ReactSurfaceOptions = {
+  logBuffer: LogBuffer;
+};
+
+export default Capability.makeModule(
+  Effect.fnUntraced(function* ({ logBuffer }: ReactSurfaceOptions) {
+    const capabilities = yield* Capability.Service;
+    const registry = capabilities.get(Capabilities.AtomRegistry);
+    const settingsAtom = capabilities.get(DebugCapabilities.Settings);
+
+    return Capability.contributes(Capabilities.ReactSurface, [
+      Surface.create({
+        id: `${meta.id}.plugin-settings`,
+        role: 'article',
+        filter: (data): data is { subject: AppCapabilities.Settings } =>
+          AppCapabilities.isSettings(data.subject) && data.subject.prefix === meta.id,
+        component: ({ data: { subject } }) => {
+          const { settings, updateSettings } = useSettingsState<DebugSettingsProps>(subject.atom);
+          return <DebugSettings settings={settings} onSettingsChange={updateSettings} logBuffer={logBuffer} />;
+        },
+      }),
+      Surface.create({
+        id: `${meta.id}.space`,
+        role: 'article',
+        filter: (data): data is { subject: SpaceDebug } => isSpaceDebug(data.subject),
+        component: ({ role, data }) => {
+          const { invokePromise } = useOperationInvoker();
+
+          const handleCreateObject = useCallback(
+            (objects: Obj.Unknown[]) => {
+              if (!isSpace(data.subject.space)) {
+                return;
+              }
+
+              const collection =
+                data.subject.space.state.get() === SpaceState.SPACE_READY &&
+                data.subject.space.properties[Collection.Collection.typename]?.target;
+              if (!Obj.instanceOf(Collection.Collection, collection)) {
+                return;
+              }
+
+              objects.forEach((object) => {
+                void invokePromise(SpaceOperation.AddObject, {
+                  target: collection,
+                  object,
+                });
+              });
+            },
+            [data.subject.space, invokePromise],
+          );
+
+          return (
+            <Panel.Root role={role} className='dx-document'>
+              <Panel.Content asChild>
+                <SpaceGenerator space={data.subject.space} onCreateObjects={handleCreateObject} />
+              </Panel.Content>
+            </Panel.Root>
+          );
+        },
+      }),
+      Surface.create({
+        id: `${meta.id}.app-graph`,
+        role: 'article',
+        filter: (data): data is { subject: GraphDebug } => isGraphDebug(data.subject),
+        component: ({ data }) => <DebugGraph graph={data.subject.graph} root={data.subject.root} />,
+      }),
+      Surface.create({
+        id: `${meta.id}.wireframe`,
+        role: ['article', 'section'],
+        position: 'hoist',
+        filter: (data): data is { subject: Obj.Unknown } => {
+          const settings = registry.get(settingsAtom);
+          return Obj.isObject(data.subject) && !!settings.wireframe;
+        },
+        component: ({ data, role, name }) => (
+          <Wireframe label={`${role}:${name}`} object={data.subject} classNames='row-span-2 overflow-hidden' />
+        ),
+      }),
+      Surface.create({
+        id: `${meta.id}.object-debug`,
+        role: 'article',
+        filter: (data): data is { companionTo: Obj.Unknown } =>
+          data.subject === 'debug' && Obj.isObject(data.companionTo),
+        component: ({ data }) => <DebugObjectPanel object={data.companionTo} />,
+      }),
+      Surface.create({
+        id: `${meta.id}.devtools-overview`,
+        role: 'deck-companion--devtools',
+        filter: (data): data is { subject: 'devtools' } => data.subject === 'devtools',
+        component: () => <DevtoolsOverviewContainer />,
+      }),
+      Surface.create({
+        id: `${meta.id}.space-objects`,
+        role: 'deck-companion--space-objects',
+        filter: (data): data is { subject: 'space-objects' } => data.subject === 'space-objects',
+        component: () => <DebugSpaceObjectsPanel />,
+      }),
+
+      Surface.create({
+        id: `${meta.id}.status`,
+        role: 'status-indicator',
+        position: 'hoist',
+        component: () => <DebugStatus />,
+      }),
+      //
+      // Devtools
+      //
+
+      Surface.create({
+        id: `${meta.id}.client.config`,
+        role: 'article',
+        filter: (data): data is any => data.subject === Devtools.Client.Config,
+        component: () => <ConfigPanel vaultSelector={false} />,
+      }),
+      Surface.create({
+        id: `${meta.id}.client.storage`,
+        role: 'article',
+        filter: (data): data is any => data.subject === Devtools.Client.Storage,
+        component: () => <StoragePanel />,
+      }),
+      Surface.create({
+        id: `${meta.id}.client.logs`,
+        role: 'article',
+        filter: (data): data is any => data.subject === Devtools.Client.Logs,
+        component: () => <LoggingPanel />,
+      }),
+      Surface.create({
+        id: `${meta.id}.client.diagnostics`,
+        role: 'article',
+        filter: (data): data is any => data.subject === Devtools.Client.Diagnostics,
+        component: () => <DiagnosticsPanel />,
+      }),
+      Surface.create({
+        id: `${meta.id}.client.tracing`,
+        role: 'article',
+        filter: (data): data is any => data.subject === Devtools.Client.Tracing,
+        component: () => <TracingPanel />,
+      }),
+      Surface.create({
+        id: `${meta.id}.halo.identity`,
+        role: 'article',
+        filter: (data): data is any => data.subject === Devtools.Halo.Identity,
+        component: () => <IdentityPanel />,
+      }),
+      Surface.create({
+        id: `${meta.id}.halo.devices`,
+        role: 'article',
+        filter: (data): data is any => data.subject === Devtools.Halo.Devices,
+        component: () => <DeviceListPanel />,
+      }),
+      Surface.create({
+        id: `${meta.id}.halo.keyring`,
+        role: 'article',
+        filter: (data): data is any => data.subject === Devtools.Halo.Keyring,
+        component: () => <KeyringPanel />,
+      }),
+      Surface.create({
+        id: `${meta.id}.halo.credentials`,
+        role: 'article',
+        filter: (data): data is any => data.subject === Devtools.Halo.Credentials,
+        component: () => {
+          const space = useCurrentSpace();
+          return <CredentialsPanel space={space} />;
+        },
+      }),
+      Surface.create({
+        id: `${meta.id}.echo.spaces`,
+        role: 'article',
+        filter: (data): data is any => data.subject === Devtools.Echo.Spaces,
+        component: () => {
+          const { invokePromise } = useOperationInvoker();
+          const handleSelect = useCallback(
+            () => invokePromise(LayoutOperation.Open, { subject: [Devtools.Echo.Space] }),
+            [invokePromise],
+          );
+          return <SpaceListPanel onSelect={handleSelect} />;
+        },
+      }),
+      Surface.create({
+        id: `${meta.id}.echo.space`,
+        role: 'article',
+        filter: (data): data is any => data.subject === Devtools.Echo.Space,
+        component: () => {
+          const space = useCurrentSpace();
+          const { invokePromise } = useOperationInvoker();
+          const handleSelect = useCallback(
+            () => invokePromise(LayoutOperation.Open, { subject: [Devtools.Echo.Feeds] }),
+            [invokePromise],
+          );
+          return <SpaceInfoPanel space={space} onSelectFeed={handleSelect} onSelectPipeline={handleSelect} />;
+        },
+      }),
+      Surface.create({
+        id: `${meta.id}.echo.feeds`,
+        role: 'article',
+        filter: (data): data is any => data.subject === Devtools.Echo.Feeds,
+        component: () => {
+          const space = useCurrentSpace();
+          return <FeedsPanel space={space} />;
+        },
+      }),
+      Surface.create({
+        id: `${meta.id}.echo.objects`,
+        role: 'article',
+        filter: (data): data is any => data.subject === Devtools.Echo.Objects,
+        component: () => {
+          const space = useCurrentSpace();
+          return <ObjectsPanel space={space} />;
+        },
+      }),
+      Surface.create({
+        id: `${meta.id}.echo.schema`,
+        role: 'article',
+        filter: (data): data is any => data.subject === Devtools.Echo.Schema,
+        component: () => {
+          const space = useCurrentSpace();
+          return <SchemaPanel space={space} />;
+        },
+      }),
+      Surface.create({
+        id: `${meta.id}.echo.automerge`,
+        role: 'article',
+        filter: (data): data is any => data.subject === Devtools.Echo.Automerge,
+        component: () => {
+          const space = useCurrentSpace();
+          return <AutomergePanel space={space} />;
+        },
+      }),
+      Surface.create({
+        id: `${meta.id}.echo.queues`,
+        role: 'article',
+        filter: (data): data is any => data.subject === Devtools.Echo.Queues,
+        component: () => <QueuesPanel />,
+      }),
+      Surface.create({
+        id: `${meta.id}.echo.members`,
+        role: 'article',
+        filter: (data): data is any => data.subject === Devtools.Echo.Members,
+        component: () => {
+          const space = useCurrentSpace();
+          return <MembersPanel space={space} />;
+        },
+      }),
+      Surface.create({
+        id: `${meta.id}.echo.metadata`,
+        role: 'article',
+        filter: (data): data is any => data.subject === Devtools.Echo.Metadata,
+        component: () => <MetadataPanel />,
+      }),
+      Surface.create({
+        id: `${meta.id}.mesh.signal`,
+        role: 'article',
+        filter: (data): data is any => data.subject === Devtools.Mesh.Signal,
+        component: () => <SignalPanel />,
+      }),
+      Surface.create({
+        id: `${meta.id}.mesh.swarm`,
+        role: 'article',
+        filter: (data): data is any => data.subject === Devtools.Mesh.Swarm,
+        component: () => <SwarmPanel />,
+      }),
+      Surface.create({
+        id: `${meta.id}.mesh.network`,
+        role: 'article',
+        filter: (data): data is any => data.subject === Devtools.Mesh.Network,
+        component: () => {
+          const space = useCurrentSpace();
+          return <NetworkPanel space={space} />;
+        },
+      }),
+      Surface.create({
+        id: `${meta.id}.edge.dashboard`,
+        role: 'article',
+        filter: (data): data is any => data.subject === Devtools.Edge.Dashboard,
+        component: () => <EdgeDashboardPanel />,
+      }),
+      Surface.create({
+        id: `${meta.id}.edge.workflows`,
+        role: 'article',
+        filter: (data): data is any => data.subject === Devtools.Edge.Workflows,
+        component: () => {
+          const space = useCurrentSpace();
+          return <WorkflowPanel space={space} />;
+        },
+      }),
+      Surface.create({
+        id: `${meta.id}.edge.traces`,
+        role: 'article',
+        filter: (data): data is any => data.subject === Devtools.Edge.Traces,
+        component: () => {
+          const space = useCurrentSpace();
+          const queueDxn = space?.properties.invocationTraceQueue?.dxn;
+          return <InvocationTraceContainer db={space?.db} queueDxn={queueDxn} detailAxis='block' />;
+        },
+      }),
+      Surface.create({
+        id: `${meta.id}.edge.testing`,
+        role: 'article',
+        filter: (data): data is any => data.subject === Devtools.Edge.Testing,
+        component: () => {
+          const { invokePromise } = useOperationInvoker();
+          const onSpaceCreate = useCallback(
+            async (space: Space) => {
+              await space.waitUntilReady();
+              await invokePromise(SpaceOperation.Migrate, { space });
+              await space.db.flush();
+            },
+            [invokePromise],
+          );
+          const onScriptPluginOpen = useCallback(
+            async (space: Space) => {
+              await space.waitUntilReady();
+              const createResult = await invokePromise(ScriptOperation.CreateScript, { db: space.db });
+              if (createResult.data?.object) {
+                await invokePromise(SpaceOperation.AddObject, { target: space.db, object: createResult.data.object });
+              }
+              log.info('script created', { result: createResult });
+              if (createResult.data?.object) {
+                await invokePromise(LayoutOperation.Open, {
+                  subject: [getObjectPathFromObject(createResult.data.object)],
+                });
+              }
+            },
+            [invokePromise],
+          );
+          return <TestingPanel onSpaceCreate={onSpaceCreate} onScriptPluginOpen={onScriptPluginOpen} />;
+        },
+      }),
+    ]);
+  }),
+);

package/src/capabilities/settings/index.ts

@@ -0,0 +1,7 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Capability } from '@dxos/app-framework';
+
+export const DebugSettings = Capability.lazy('DebugSettings', () => import('./settings'));

package/src/capabilities/settings/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 { DebugCapabilities, DebugSettingsSchema } from '../../types';
+
+export default Capability.makeModule(() =>
+  Effect.sync(() => {
+    const settingsAtom = createKvsStore({
+      key: meta.id,
+      schema: DebugSettingsSchema,
+      defaultValue: () => ({}),
+    });
+
+    return [
+      Capability.contributes(DebugCapabilities.Settings, settingsAtom),
+      Capability.contributes(AppCapabilities.Settings, {
+        prefix: meta.id,
+        schema: DebugSettingsSchema,
+        atom: settingsAtom,
+      }),
+    ];
+  }),
+);

package/src/components/{SpaceGenerator → SchemaTable}/SchemaTable.tsx

@@ -19,8 +19,8 @@ export const SchemaTable = ({ types, objects = {}, label, onClick }: SchemaTable
       <h2 className='p-2'>{label}</h2>
       {types.map((type) => (
         <div key={type.typename} className='grid grid-cols-subgrid col-span-3 items-center'>
-          <div className='pli-2 text-sm font-mono text-subdued'>{type.typename}</div>
-          <div className='pli-2 text-right font-mono'>{objects[type.typename] ?? 0}</div>
+          <div className='px-2 text-sm font-mono text-subdued'>{type.typename}</div>
+          <div className='px-2 text-right font-mono'>{objects[type.typename] ?? 0}</div>
           <IconButton
             variant='ghost'
             icon='ph--plus--regular'

package/src/components/SchemaTable/index.ts

@@ -0,0 +1,5 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+export * from './SchemaTable';

package/src/components/SpaceGenerator/ObjectGenerator.tsx

@@ -2,19 +2,21 @@
 // Copyright 2024 DXOS.org
 //
 
-import { type PromiseIntentDispatcher, createIntent } from '@dxos/app-framework';
+import type * as Schema from 'effect/Schema';
+
 import { addressToA1Notation } from '@dxos/compute';
 import { ComputeGraph, ComputeGraphModel, DEFAULT_OUTPUT, NODE_INPUT, NODE_OUTPUT } from '@dxos/conductor';
-import { DXN, Filter, Key, type Obj, Type } from '@dxos/echo';
-import { type TypedObject } from '@dxos/echo/internal';
+import { DXN, Filter, Key, type Type } from '@dxos/echo';
+import { View } from '@dxos/echo';
+import { type OperationInvoker } from '@dxos/operation';
 import { Markdown } from '@dxos/plugin-markdown/types';
 import { Sheet } from '@dxos/plugin-sheet/types';
-import { Diagram } from '@dxos/plugin-sketch/types';
-import { SpaceAction } from '@dxos/plugin-space/types';
+import { Sketch } from '@dxos/plugin-sketch/types';
+import { SpaceOperation } from '@dxos/plugin-space/operations';
 import { faker } from '@dxos/random';
 import { type Client } from '@dxos/react-client';
 import { type Space } from '@dxos/react-client/echo';
-import { View, getTypenameFromQuery } from '@dxos/schema';
+import { getTypenameFromQuery } from '@dxos/schema';
 import { type ValueGenerator, createAsyncGenerator } from '@dxos/schema/testing';
 import { range } from '@dxos/util';
 
@@ -24,24 +26,22 @@ const findViewByTypename = async (views: View.View[], typename: string) => {
   return views.find((view) => getTypenameFromQuery(view.query.ast) === typename);
 };
 
-export type ObjectGenerator<T extends Obj.Any> = (space: Space, n: number, cb?: (objects: T[]) => void) => Promise<T[]>;
+export type ObjectGenerator<T> = (space: Space, n: number, cb?: (objects: T[]) => void) => Promise<T[]>;
 
-export const createGenerator = <T extends Obj.Any>(
+export const createGenerator = <S extends Type.AnyObj>(
   client: Client,
-  dispatch: PromiseIntentDispatcher,
-  schema: TypedObject<T>,
-): ObjectGenerator<T> => {
-  return async (space: Space, n: number): Promise<T[]> => {
+  invokePromise: OperationInvoker.OperationInvoker['invokePromise'],
+  schema: S,
+): ObjectGenerator<Schema.Schema.Type<S>> => {
+  return async (space: Space, n: number): Promise<Schema.Schema.Type<S>[]> => {
     const typename = schema.typename;
 
     // Find or create table and view.
-    const { objects: views } = await space.db.query(Filter.type(View.View)).run();
+    const views = await space.db.query(Filter.type(View.View)).run();
     const view = await findViewByTypename(views, typename);
-    const staticSchema = client?.graph.schemaRegistry.schemas.find((schema) => Type.getTypename(schema) === typename);
+    const staticSchema = client?.graph.schemaRegistry.query({ typename }).runSync()[0];
     if (!view && !staticSchema) {
-      await dispatch(createIntent(SpaceAction.AddSchema, { space, schema, show: false }));
-    } else if (!view && staticSchema) {
-      await dispatch(createIntent(SpaceAction.UseStaticSchema, { space, typename, show: false }));
+      await invokePromise(SpaceOperation.AddSchema, { db: space.db, schema, show: false });
     }
 
     // Create objects.
@@ -68,12 +68,10 @@ export const staticGenerators = new Map<string, ObjectGenerator<any>>([
     },
   ],
   [
-    Diagram.Diagram.typename,
+    Sketch.Sketch.typename,
     async (space, n, cb) => {
       const objects = range(n).map(() => {
-        // TODO(burdon): Generate diagram.
-        const obj = space.db.add(Diagram.make({ name: faker.commerce.productName() }));
-
+        const obj = space.db.add(Sketch.make({ name: faker.commerce.productName() }));
         return obj;
       });
 

package/src/components/SpaceGenerator/index.ts

@@ -2,6 +2,5 @@
 // Copyright 2023 DXOS.org
 //
 
-import { SpaceGenerator } from './SpaceGenerator';
-
-export default SpaceGenerator;
+export * from './presets';
+export * from './ObjectGenerator';