@dxos/plugin-automation 0.8.4-main.ead640a → 0.8.4-main.effb148878

package/src/components/TriggerEditor/TriggerEditor.tsx

@@ -2,85 +2,114 @@
 // Copyright 2025 DXOS.org
 //
 
+import * as Option from 'effect/Option';
+import * as Record from 'effect/Record';
 import React, { useCallback, useMemo } from 'react';
 
+import { Operation, Script, Trigger } from '@dxos/compute';
 import { ComputeGraph } from '@dxos/conductor';
-import { type Query, Type } from '@dxos/echo';
-import { FunctionTrigger, FunctionType, ScriptType } from '@dxos/functions';
-import { Filter, Ref, type Space, useQuery } from '@dxos/react-client/echo';
+import { Annotation, type Database, Entity, Feed, Filter, Obj, type Query, Ref, Type } from '@dxos/echo';
+import { EchoURI } from '@dxos/keys';
+import { useQuery } from '@dxos/react-client/echo';
 import { Input } from '@dxos/react-ui';
 import { QueryForm, type QueryFormProps } from '@dxos/react-ui-components';
-import { type CustomInputMap, Form, InputHeader, SelectInput, useRefQueryLookupHandler } from '@dxos/react-ui-form';
-
-import { FunctionInputEditor, type FunctionInputEditorProps } from './FunctionInputEditor';
+import {
+  type ExcludeId,
+  Form,
+  FormFieldLabel,
+  type FormFieldMap,
+  type FormRootProps,
+  SelectField,
+  omitId,
+} from '@dxos/react-ui-form';
+
+import { FunctionInputEditor } from './FunctionInputEditor';
 import { SpecSelector } from './SpecSelector';
 
+type TriggerFormSchema = ExcludeId<typeof Trigger.Trigger>;
+
 export type TriggerEditorProps = {
-  space: Space;
-  trigger: FunctionTrigger;
+  db: Database.Database;
+  trigger: Trigger.Trigger;
   // TODO(wittjosiah): This needs to apply to whole spec but currently only applies to spec.kind & spec.query.
   readonlySpec?: boolean;
-  onSave?: (trigger: Omit<FunctionTrigger, 'id'>) => void;
-  onCancel?: () => void;
-} & Pick<QueryFormProps, 'types' | 'tags'>;
-
-export const TriggerEditor = ({ space, trigger, readonlySpec, types, tags, onSave, onCancel }: TriggerEditorProps) => {
-  const handleSave = ({ id: _, ...values }: FunctionTrigger) => {
-    onSave?.(values);
-  };
+} &
+  // prettier-ignore
+  Pick<QueryFormProps, 'types' | 'tags'> &
+  Pick<FormRootProps<TriggerFormSchema>, 'onSave' | 'onCancel'>;
+
+export const TriggerEditor = ({ db, types, tags, readonlySpec, trigger, ...formProps }: TriggerEditorProps) => {
+  const fieldMap = useCustomInputs({ db, types, tags, readonlySpec });
+
+  const handleValuesChanged = useCallback(
+    (newValues: Partial<TriggerFormSchema>) => {
+      Obj.update(trigger, (trigger) => {
+        Object.assign(trigger, newValues);
+      });
+    },
+    [trigger],
+  );
 
-  const handleRefQueryLookup = useRefQueryLookupHandler({ space });
-  const Custom = useCustomInputs({ space, readonlySpec, types, tags, onQueryRefOptions: handleRefQueryLookup });
+  const triggerSchema = useMemo(() => omitId(Trigger.Trigger), []);
+  const defaultValues = useMemo(() => {
+    const { id: _, ...values } = trigger;
+    return values;
+  }, [trigger]);
 
   return (
-    <Form
-      outerSpacing={false}
-      Custom={Custom}
-      schema={FunctionTrigger}
-      values={trigger}
-      onSave={handleSave}
-      onCancel={onCancel}
-      onQueryRefOptions={handleRefQueryLookup}
-    />
+    <Form.Root<TriggerFormSchema>
+      {...formProps}
+      db={db}
+      schema={triggerSchema}
+      defaultValues={defaultValues}
+      fieldMap={fieldMap}
+      onValuesChanged={handleValuesChanged}
+    >
+      <Form.Viewport>
+        <Form.Content>
+          <Form.FieldSet />
+          <Form.Actions />
+        </Form.Content>
+      </Form.Viewport>
+    </Form.Root>
   );
 };
 
 type UseCustomInputsProps = {
-  space: Space;
+  db: Database.Database;
   readonlySpec?: boolean;
-  onQueryRefOptions: FunctionInputEditorProps['onQueryRefOptions'];
 } & Pick<QueryFormProps, 'types' | 'tags'>;
 
-const useCustomInputs = ({ space, readonlySpec, types, tags, onQueryRefOptions }: UseCustomInputsProps) => {
-  const functions = useQuery(space, Filter.type(FunctionType));
-  const workflows = useQuery(space, Filter.type(ComputeGraph));
-  const scripts = useQuery(space, Filter.type(ScriptType));
+const useCustomInputs = ({ db, readonlySpec, types, tags }: UseCustomInputsProps): FormFieldMap => {
+  const functions = useQuery(db, Filter.type(Operation.PersistentOperation));
+  const workflows = useQuery(db, Filter.type(ComputeGraph));
+  const scripts = useQuery(db, Filter.type(Script.Script));
+  const feeds = useQuery(db, Filter.type(Feed.Feed));
 
   return useMemo(
-    (): CustomInputMap => ({
+    (): FormFieldMap => ({
       // Function selector.
-      ['function' satisfies keyof FunctionTrigger]: (props) => {
+      ['function' satisfies keyof Trigger.Trigger]: (props) => {
         const getValue = useCallback(() => {
           const formValue = props.getValue();
           if (Ref.isRef(formValue)) {
-            return formValue.dxn.toString() as string;
+            return formValue.uri;
           }
           return undefined;
         }, [props]);
 
         const handleOnValueChange = useCallback(
-          (_type: any, dxnString: string) => {
-            const dxn = Type.DXN.parse(dxnString);
-            if (dxn) {
-              const ref = Ref.fromDXN(dxn);
-              props.onValueChange('object', ref);
+          (_type: any, uriString: string) => {
+            const uri = EchoURI.tryParse(uriString);
+            if (uri) {
+              props.onValueChange(props.type, Ref.fromURI(uri));
             }
           },
-          [props.onValueChange],
+          [props.type, props.onValueChange],
         );
 
         return (
-          <SelectInput
+          <SelectField
             {...props}
             getValue={getValue as any}
             onValueChange={handleOnValueChange}
@@ -90,38 +119,126 @@ const useCustomInputs = ({ space, readonlySpec, types, tags, onQueryRefOptions }
       },
 
       // Spec selector.
-      ['spec.kind' as const]: (props) => <SpecSelector {...props} readonly={readonlySpec ? 'disabled-input' : false} />,
+      'spec.kind': (props) => <SpecSelector {...props} readonly={readonlySpec} />,
+
+      // Feed selector with parent labels.
+      'spec.feed': (props) => {
+        const getValue = useCallback(() => {
+          const formValue = props.getValue();
+          if (Ref.isRef(formValue)) {
+            return formValue.uri.toString() as string;
+          }
+          return undefined;
+        }, [props]);
+
+        const handleOnValueChange = useCallback(
+          (_type: any, dxnString: string) => {
+            const uri = EchoURI.tryParse(dxnString);
+            if (uri) {
+              props.onValueChange(props.type, Ref.fromURI(uri));
+            }
+          },
+          [props.type, props.onValueChange],
+        );
+
+        return (
+          <SelectField
+            {...props}
+            getValue={getValue as any}
+            onValueChange={handleOnValueChange}
+            options={getFeedOptions(feeds)}
+          />
+        );
+      },
 
       // TODO(wittjosiah): Copied from ViewEditor.
       // Query input editor.
-      ['spec.query' as const]: (props) => {
+      'spec.query': (props) => {
         const handleChange = useCallback(
-          (query: Query.Any) => props.onValueChange('object', { ast: query.ast }),
-          [props.onValueChange],
+          (query: Query.Any) => props.onValueChange(props.type, { ast: query.ast }),
+          [props.type, props.onValueChange],
         );
 
         return (
           <Input.Root>
-            <InputHeader label={props.label} />
+            <FormFieldLabel label={props.label} asChild />
             <QueryForm initialQuery={(props.getValue() as any).ast} types={types} tags={tags} onChange={handleChange} />
           </Input.Root>
         );
       },
 
       // Function input editor.
-      ['input' as const]: (props) => (
-        <FunctionInputEditor {...props} functions={functions} onQueryRefOptions={onQueryRefOptions} />
-      ),
+      input: (props) => <FunctionInputEditor {...props} functions={functions} db={db} />,
     }),
-    [workflows, scripts, functions, readonlySpec],
+    [workflows, scripts, functions, feeds, readonlySpec],
   );
 };
 
+const getObjectIconProps = (object: Entity.Unknown): { icon?: string; iconHue?: string } => {
+  const type = Entity.getType(object);
+  const schema = type ? Type.getSchema(type) : undefined;
+  const annotation = schema ? Option.getOrUndefined(Annotation.IconAnnotation.get(schema)) : undefined;
+  return annotation ? { icon: annotation.icon, iconHue: annotation.hue } : {};
+};
+
 const getWorkflowOptions = (graphs: ComputeGraph[]) => {
-  return graphs.map((graph) => ({ label: `compute-${graph.id}`, value: `dxn:echo:@:${graph.id}` }));
+  return graphs.map((graph) => ({
+    label: `compute-${graph.id}`,
+    value: Obj.getURI(graph),
+    ...getObjectIconProps(graph),
+  }));
+};
+
+const getFunctionOptions = (scripts: Script.Script[], functions: Operation.PersistentOperation[]) => {
+  const getLabel = (fn: Operation.PersistentOperation) =>
+    scripts.find((s) => fn.source?.target?.id === s.id)?.name ?? fn.name;
+  return functions.map((fn) => {
+    const { icon: schemaIcon, iconHue } = getObjectIconProps(fn);
+    return {
+      label: getLabel(fn),
+      value: Obj.getURI(fn),
+      icon: fn.icon ?? schemaIcon,
+      iconHue,
+    };
+  });
+};
+
+const getFeedDisplayName = (feed: Feed.Feed): string =>
+  Entity.getLabel(feed) ?? feed.name ?? Entity.getTypename(feed) ?? 'Feed';
+
+const computeRefRole = (entity: Feed.Feed): string | undefined => {
+  const parent = Obj.getParent(entity);
+  if (!parent) {
+    return undefined;
+  }
+  for (const key of Record.keys(parent)) {
+    if (Ref.isRef(parent[key]) && parent[key].target?.id === entity.id) {
+      return `$.${key}`;
+    }
+  }
+  return undefined;
 };
 
-const getFunctionOptions = (scripts: ScriptType[], functions: FunctionType[]) => {
-  const getLabel = (fn: FunctionType) => scripts.find((s) => fn.source?.target?.id === s.id)?.name ?? fn.name;
-  return functions.map((fn) => ({ label: getLabel(fn), value: `dxn:echo:@:${fn.id}` }));
+const getFeedOptions = (feeds: Feed.Feed[]) => {
+  return feeds.map((feed) => {
+    const parent = Obj.getParent(feed);
+    const displayObject = parent ?? feed;
+    const role = computeRefRole(feed);
+
+    if (parent) {
+      return {
+        label: Entity.getLabel(parent) ?? Entity.getTypename(parent) ?? 'Parent',
+        secondaryLabel: role ?? getFeedDisplayName(feed),
+        value: Obj.getURI(feed),
+        ...getObjectIconProps(displayObject),
+      };
+    }
+
+    return {
+      label: getFeedDisplayName(feed),
+      secondaryLabel: role,
+      value: Obj.getURI(feed),
+      ...getObjectIconProps(displayObject),
+    };
+  });
 };

package/src/components/index.ts

@@ -7,6 +7,5 @@ import { lazy } from 'react';
 export * from './TriggerEditor';
 
 export const AutomationPanel = lazy(() => import('./AutomationPanel'));
-export const AutomationSettings = lazy(() => import('./AutomationSettings'));
-export const FunctionsContainer = lazy(() => import('./FunctionsContainer'));
 export const FunctionsPanel = lazy(() => import('./FunctionsPanel'));
+export const FunctionsRegistry = lazy(() => import('./FunctionsRegistry'));

package/src/containers/AutomationSettings/AutomationSettings.tsx

@@ -0,0 +1,31 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import React from 'react';
+
+import { AppSurface } from '@dxos/app-toolkit/ui';
+import { useTranslation } from '@dxos/react-ui';
+import { Settings } from '@dxos/react-ui-form';
+
+import { meta } from '#meta';
+
+import { AutomationPanel, type AutomationPanelProps } from '../../components/AutomationPanel';
+import { TriggersSettings } from '../TriggerSettings';
+
+export type AutomationSettingsProps = AppSurface.SpaceArticleProps<Omit<AutomationPanelProps, 'space'>>;
+
+export const AutomationSettings = (props: AutomationSettingsProps) => {
+  const { t } = useTranslation(meta.id);
+  return (
+    <Settings.Viewport>
+      <Settings.Section
+        title={t('automation-verbose.label', { ns: meta.id })}
+        description={t('automation.description', { ns: meta.id })}
+      >
+        <AutomationPanel {...props} />
+        <TriggersSettings space={props.space} />
+      </Settings.Section>
+    </Settings.Viewport>
+  );
+};

package/src/containers/AutomationSettings/index.ts

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

package/src/containers/FunctionsContainer/FunctionsContainer.tsx

@@ -0,0 +1,33 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import React from 'react';
+
+import { AppSurface } from '@dxos/app-toolkit/ui';
+import { useTranslation } from '@dxos/react-ui';
+import { Settings } from '@dxos/react-ui-form';
+
+import { meta } from '#meta';
+
+import { FunctionsPanel, FunctionsRegistry } from '../../components';
+
+export const FunctionsContainer = ({ space }: AppSurface.SpaceArticleProps) => {
+  const { t } = useTranslation(meta.id);
+  return (
+    <Settings.Viewport>
+      <Settings.Section
+        title={t('functions-verbose.label', { ns: meta.id })}
+        description={t('functions.description', { ns: meta.id })}
+      >
+        <FunctionsPanel space={space} />
+      </Settings.Section>
+      <Settings.Section
+        title={t('functions-registry-verbose.label', { ns: meta.id })}
+        description={t('functions-registry.description', { ns: meta.id })}
+      >
+        <FunctionsRegistry space={space} />
+      </Settings.Section>
+    </Settings.Viewport>
+  );
+};

package/src/containers/FunctionsContainer/index.ts

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

package/src/containers/TriggerSettings/TriggerSettings.tsx

@@ -0,0 +1,48 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import React from 'react';
+
+import { type ComputeEnvironment } from '@dxos/client-protocol';
+import { useObject } from '@dxos/echo-react';
+import { type Space } from '@dxos/react-client/echo';
+import { DropdownMenu, IconButton, useTranslation } from '@dxos/react-ui';
+import { Settings } from '@dxos/react-ui-form';
+
+import { meta } from '#meta';
+
+export const TriggersSettings = ({ space }: { space: Space }) => {
+  const { t } = useTranslation(meta.id);
+  const [properties, changeProperties] = useObject(space.properties);
+  const selected = properties.computeEnvironment ?? 'local';
+
+  const handleUpdate = (option: ComputeEnvironment) => {
+    changeProperties((draft) => {
+      draft.computeEnvironment = option;
+    });
+  };
+
+  return (
+    <div className='grid grid-cols-1 md:grid-cols-[1fr_min-content]'>
+      <Settings.Item title={t('runtime.label')} description={t('runtime.description')}>
+        <DropdownMenu.Root>
+          <DropdownMenu.Trigger asChild>
+            <IconButton iconEnd icon='ph--caret-down--regular' size={4} label={t(`runtime.${selected}.label`)} />
+          </DropdownMenu.Trigger>
+          <DropdownMenu.Portal>
+            <DropdownMenu.Content side='bottom'>
+              <DropdownMenu.Viewport>
+                <DropdownMenu.Item onClick={() => handleUpdate('disabled')}>
+                  {t(`runtime.disabled.label`)}
+                </DropdownMenu.Item>
+                <DropdownMenu.Item onClick={() => handleUpdate('local')}>{t(`runtime.local.label`)}</DropdownMenu.Item>
+                <DropdownMenu.Item onClick={() => handleUpdate('edge')}>{t(`runtime.edge.label`)}</DropdownMenu.Item>
+              </DropdownMenu.Viewport>
+            </DropdownMenu.Content>
+          </DropdownMenu.Portal>
+        </DropdownMenu.Root>
+      </Settings.Item>
+    </div>
+  );
+};

package/src/containers/TriggerSettings/index.ts

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

package/src/containers/index.ts

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

package/src/hooks/index.ts

@@ -2,5 +2,6 @@
 // Copyright 2025 DXOS.org
 //
 
-export * from './useComputeRuntimeCallback';
+// TODO(wittjosiah): Factor out.
+export * from './useEdgeTriggersDispatcherStatus';
 export * from './useTriggerRuntimeControls';

package/src/hooks/useEdgeTriggersDispatcherStatus.ts

@@ -0,0 +1,78 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { useEffect, useMemo, useState } from 'react';
+
+import { Context } from '@dxos/context';
+import { type TriggersDispatcherStatus } from '@dxos/edge-client';
+import { FunctionsServiceClient } from '@dxos/functions-runtime/edge';
+import { type SpaceId } from '@dxos/keys';
+import { log } from '@dxos/log';
+import { useClient } from '@dxos/react-client';
+import { useIdentity } from '@dxos/react-client/halo';
+
+const POLL_INTERVAL_MS = 5_000;
+
+export type EdgeTriggersDispatcherStatusState = {
+  status: TriggersDispatcherStatus | undefined;
+  error: boolean;
+  loading: boolean;
+};
+
+/**
+ * Polls Edge TriggersDispatcher status for a space while enabled.
+ * Uses {@link FunctionsServiceClient} so requests are authenticated like other edge trigger calls.
+ */
+export const useEdgeTriggersDispatcherStatus = (
+  spaceId: SpaceId | undefined,
+  enabled: boolean,
+): EdgeTriggersDispatcherStatusState => {
+  const client = useClient();
+  const identity = useIdentity();
+  const functionsServiceClient = useMemo(() => FunctionsServiceClient.fromClient(client), [client]);
+  const [status, setStatus] = useState<TriggersDispatcherStatus | undefined>();
+  const [error, setError] = useState(false);
+  const [loading, setLoading] = useState(false);
+
+  useEffect(() => {
+    if (!enabled || !spaceId || !identity) {
+      setStatus(undefined);
+      setError(false);
+      setLoading(false);
+      return;
+    }
+
+    let cancelled = false;
+
+    const fetchStatus = async () => {
+      try {
+        setLoading(true);
+        const result = await functionsServiceClient.getTriggersDispatcherStatus(Context.default(), spaceId);
+        if (!cancelled) {
+          setStatus(result);
+          setError(false);
+        }
+      } catch (err) {
+        log.catch(err);
+        if (!cancelled) {
+          setError(true);
+        }
+      } finally {
+        if (!cancelled) {
+          setLoading(false);
+        }
+      }
+    };
+
+    void fetchStatus();
+    const interval = setInterval(() => void fetchStatus(), POLL_INTERVAL_MS);
+
+    return () => {
+      cancelled = true;
+      clearInterval(interval);
+    };
+  }, [enabled, functionsServiceClient, identity, spaceId]);
+
+  return { status, error, loading };
+};

package/src/hooks/useTriggerRuntimeControls.ts

@@ -2,50 +2,70 @@
 // Copyright 2025 DXOS.org
 //
 
+import { Atom, useAtomValue } from '@effect-atom/atom-react';
+import type * as Context from 'effect/Context';
 import * as Effect from 'effect/Effect';
+import { useEffect, useState } from 'react';
 
-import { Filter } from '@dxos/echo';
-import { FunctionTrigger, TriggerDispatcher } from '@dxos/functions';
-import { type Space, useQuery } from '@dxos/react-client/echo';
-import { useAsyncState } from '@dxos/react-ui';
-
-import { useComputeRuntimeCallback } from './useComputeRuntimeCallback';
+import { useSpaceCallback } from '@dxos/app-framework/ui';
+import { Trigger } from '@dxos/compute';
+import { type Database, Filter, Query } from '@dxos/echo';
+import { TriggerDispatcher, type TriggerDispatcherState } from '@dxos/functions-runtime';
+import { useQuery } from '@dxos/react-client/echo';
 
 interface TriggerRuntimeControls {
-  triggers: FunctionTrigger[];
-  isRunning: boolean;
+  triggers: Trigger.Trigger[];
+
+  state: TriggerDispatcherState | undefined;
+
   start: () => void;
   stop: () => void;
 }
 
-export const useTriggerRuntimeControls = (space: Space | undefined): TriggerRuntimeControls => {
-  const triggers = useQuery(space, Filter.type(FunctionTrigger));
+export const useTriggerRuntimeControls = (db: Database.Database | undefined): TriggerRuntimeControls => {
+  const triggers = useQuery(
+    db,
+    Query.select(Filter.type(Trigger.Trigger)).debugLabel('plugin-automation.useTriggerRuntimeControls'),
+  );
+
+  const [dispatcher, setDispatcher] = useState<Context.Tag.Service<TriggerDispatcher> | undefined>(undefined);
 
-  const [isRunningState, setIsRunningState] = useAsyncState(
-    useComputeRuntimeCallback(space, () => TriggerDispatcher.pipe(Effect.map((t) => t.running))),
+  const init = useSpaceCallback(
+    db?.spaceId,
+    [TriggerDispatcher],
+    Effect.fnUntraced(function* () {
+      const dispatcher = yield* TriggerDispatcher;
+      setDispatcher(dispatcher);
+    }),
   );
 
-  const start = useComputeRuntimeCallback(
-    space,
+  useEffect(() => {
+    void init();
+  }, []);
+
+  const state = useAtomValue(dispatcher?.state ?? Atom.make(undefined));
+
+  const start = useSpaceCallback(
+    db?.spaceId,
+    [TriggerDispatcher],
     Effect.fnUntraced(function* () {
       const dispatcher = yield* TriggerDispatcher;
       yield* dispatcher.start();
-      setIsRunningState(true);
     }),
   );
 
-  const stop = useComputeRuntimeCallback(
-    space,
+  const stop = useSpaceCallback(
+    db?.spaceId,
+    [TriggerDispatcher],
     Effect.fnUntraced(function* () {
       const dispatcher = yield* TriggerDispatcher;
       yield* dispatcher.stop();
-      setIsRunningState(false);
     }),
   );
 
   return {
     triggers,
-    isRunning: isRunningState ?? false,
+    state,
     start: () => void start(),
     stop: () => void stop(),
   };

package/src/index.ts

@@ -2,9 +2,5 @@
 // Copyright 2023 DXOS.org
 //
 
-export { AutomationCapabilities } from './capabilities';
-export * from './components';
 export * from './meta';
-export * from './events';
-
-export * from './AutomationPlugin';
+export * from './types';