@dxos/plugin-automation 0.8.4-main.7ace549 → 0.8.4-main.8baae0fced

package/src/components/TriggerEditor/TriggerEditor.tsx

@@ -4,60 +4,87 @@
 
 import React, { useCallback, useMemo } from 'react';
 
+import { Operation, Script, Trigger } from '@dxos/compute';
 import { ComputeGraph } from '@dxos/conductor';
-import { DXN, type Query } from '@dxos/echo';
-import { Function, Script, Trigger } from '@dxos/functions';
-import { Filter, Ref, type Space, useQuery } from '@dxos/react-client/echo';
+import { type Database, DXN, Entity, Feed, Filter, Obj, type Query, Ref } from '@dxos/echo';
+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;
+  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<Trigger.Trigger, 'id'>) => void;
-  onCancel?: () => void;
-} & Pick<QueryFormProps, 'types' | 'tags'>;
-
-export const TriggerEditor = ({ space, trigger, readonlySpec, types, tags, onSave, onCancel }: TriggerEditorProps) => {
-  const handleSave = ({ id: _, ...values }: Trigger.Trigger) => {
-    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={Trigger.Trigger}
-      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(Function.Function));
-  const workflows = useQuery(space, Filter.type(ComputeGraph));
-  const scripts = useQuery(space, Filter.type(Script.Script));
+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 Trigger.Trigger]: (props) => {
         const getValue = useCallback(() => {
@@ -73,14 +100,14 @@ const useCustomInputs = ({ space, readonlySpec, types, tags, onQueryRefOptions }
             const dxn = DXN.parse(dxnString);
             if (dxn) {
               const ref = Ref.fromDXN(dxn);
-              props.onValueChange('object', ref);
+              props.onValueChange(props.type, ref);
             }
           },
-          [props.onValueChange],
+          [props.type, props.onValueChange],
         );
 
         return (
-          <SelectInput
+          <SelectField
             {...props}
             getValue={getValue as any}
             onValueChange={handleOnValueChange}
@@ -90,30 +117,31 @@ 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} />,
+
+      // Queue feed selector with parent labels.
+      'spec.queue': (props) => <SelectField {...props} options={getFeedQueueOptions(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],
   );
 };
 
@@ -121,7 +149,20 @@ const getWorkflowOptions = (graphs: ComputeGraph[]) => {
   return graphs.map((graph) => ({ label: `compute-${graph.id}`, value: `dxn:echo:@:${graph.id}` }));
 };
 
-const getFunctionOptions = (scripts: Script.Script[], functions: Function.Function[]) => {
-  const getLabel = (fn: Function.Function) => scripts.find((s) => fn.source?.target?.id === s.id)?.name ?? fn.name;
+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) => ({ label: getLabel(fn), value: `dxn:echo:@:${fn.id}` }));
 };
+
+const getFeedQueueOptions = (feeds: Feed.Feed[]) => {
+  return feeds.flatMap((feed) => {
+    const queueDXN = Feed.getQueueDxn(feed);
+    if (!queueDXN) {
+      return [];
+    }
+    const parent = Obj.getParent(feed);
+    const label = parent ? Entity.getLabel(parent) : Entity.getLabel(feed);
+    return [{ label: label ?? feed.id, value: queueDXN.toString() }];
+  });
+};

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,5 @@
 // Copyright 2025 DXOS.org
 //
 
-export * from './useComputeRuntimeCallback';
+// TODO(wittjosiah): Factor out.
 export * from './useTriggerRuntimeControls';

package/src/hooks/useTriggerRuntimeControls.ts

@@ -2,51 +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 { Trigger } from '@dxos/functions';
-import { TriggerDispatcher } from '@dxos/functions-runtime';
-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: Trigger.Trigger[];
-  isRunning: boolean;
+
+  state: TriggerDispatcherState | undefined;
+
   start: () => void;
   stop: () => void;
 }
 
-export const useTriggerRuntimeControls = (space: Space | undefined): TriggerRuntimeControls => {
-  const triggers = useQuery(space, Filter.type(Trigger.Trigger));
+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,10 +2,5 @@
 // Copyright 2023 DXOS.org
 //
 
-export { AutomationCapabilities } from './capabilities';
-export * from './components';
 export * from './meta';
-export * from './events';
-export * from './hooks';
-
-export * from './AutomationPlugin';
+export * from './types';

package/src/meta.ts

@@ -2,16 +2,18 @@
 // Copyright 2023 DXOS.org
 //
 
-import { type PluginMeta } from '@dxos/app-framework';
+import { type Plugin } from '@dxos/app-framework';
 import { trim } from '@dxos/util';
 
-export const meta: PluginMeta = {
-  id: 'dxos.org/plugin/automation',
+export const meta: Plugin.Meta = {
+  id: 'org.dxos.plugin.automation',
   name: 'Automation',
+  author: 'DXOS',
   description: trim`
     Workflow automation engine that triggers custom actions based on object events and conditions.
     Create automated pipelines that respond to changes and streamline repetitive tasks.
   `,
-  icon: 'ph--robot--regular',
+  icon: 'ph--atom--regular',
   source: 'https://github.com/dxos/dxos/tree/main/packages/plugins/plugin-automation',
+  tags: ['system'],
 };

package/src/operations/create-trigger-from-template.ts

@@ -0,0 +1,71 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { LayoutOperation, getSpacePath } from '@dxos/app-toolkit';
+import { Operation, Script, Trigger } from '@dxos/compute';
+import { Filter, Obj, Ref } from '@dxos/echo';
+import { type DXN } from '@dxos/keys';
+import { SpaceOperation } from '@dxos/plugin-space';
+
+import { meta } from '#meta';
+
+import { AutomationOperation } from '../types';
+
+const handler: Operation.WithHandler<typeof AutomationOperation.CreateTriggerFromTemplate> =
+  AutomationOperation.CreateTriggerFromTemplate.pipe(
+    Operation.withHandler(
+      Effect.fnUntraced(function* ({ db, template, enabled = false, scriptName, input }) {
+        const trigger = Trigger.make({ enabled, input });
+
+        // TODO(wittjosiah): Factor out function lookup by script name?
+        if (scriptName) {
+          const scripts = yield* Effect.promise(() => db.query(Filter.type(Script.Script, { name: scriptName })).run());
+          const [script] = scripts;
+          if (script) {
+            const functions = yield* Effect.promise(() =>
+              db.query(Filter.type(Operation.PersistentOperation, { source: Ref.make(script) })).run(),
+            );
+            const [fn] = functions;
+            if (fn) {
+              Obj.update(trigger, (trigger) => {
+                trigger.function = Ref.make(fn);
+              });
+            }
+          }
+        }
+
+        switch (template.type) {
+          case 'timer': {
+            Obj.update(trigger, (trigger) => {
+              trigger.spec = Trigger.specTimer(template.cron);
+            });
+            break;
+          }
+          case 'queue': {
+            Obj.update(trigger, (trigger) => {
+              trigger.spec = Trigger.specQueue((template.queueDXN as DXN).toString());
+            });
+            break;
+          }
+          default: {
+            break;
+          }
+        }
+
+        yield* Operation.invoke(SpaceOperation.AddObject, {
+          object: trigger,
+          target: db,
+          hidden: true,
+        });
+        yield* Operation.invoke(LayoutOperation.Open, {
+          subject: [`${getSpacePath(db.spaceId)}/settings/${meta.id}.automations`],
+          workspace: getSpacePath(db.spaceId),
+        });
+      }),
+    ),
+  );
+
+export default handler;

package/src/operations/index.ts

@@ -0,0 +1,7 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { OperationHandlerSet } from '@dxos/compute';
+
+export const AutomationOperationHandlerSet = OperationHandlerSet.lazy(() => import('./create-trigger-from-template'));

package/src/plugin.ts

@@ -0,0 +1,11 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Plugin } from '@dxos/app-framework';
+
+import { meta } from './meta';
+
+export const AutomationPlugin = Plugin.lazy(meta, () => import('#plugin'));
+
+export { AutomationOperationHandlerSet } from './operations';

package/src/testing/test-functions.ts

@@ -5,13 +5,14 @@
 import * as Schema from 'effect/Schema';
 
 import { TestSchema } from '@dxos/client/testing';
-import { Type } from '@dxos/echo';
+import { JsonSchema, Ref } from '@dxos/echo';
 
 export const functions = [
   {
-    name: 'example.com/function/chess',
+    key: 'com.example.function.chess',
+    name: 'com.example.function.chess',
     version: '0.1.0',
-    inputSchema: Type.toJsonSchema(
+    inputSchema: JsonSchema.toJsonSchema(
       Schema.Struct({
         level: Schema.Number.annotations({
           title: 'Level',
@@ -20,10 +21,11 @@ export const functions = [
     ),
   },
   {
-    name: 'example.com/function/forex',
+    key: 'com.example.function.forex',
+    name: 'com.example.function.forex',
     version: '0.1.0',
     binding: 'FOREX',
-    inputSchema: Type.toJsonSchema(
+    inputSchema: JsonSchema.toJsonSchema(
       Schema.Struct({
         from: Schema.String.annotations({ title: 'Currency from' }),
         to: Schema.String.annotations({ title: 'Currency to' }),
@@ -31,11 +33,12 @@ export const functions = [
     ),
   },
   {
-    name: 'example.com/function/ping-contact',
+    key: 'com.example.function.ping-contact',
+    name: 'com.example.function.ping-contact',
     version: '0.0.1',
-    inputSchema: Type.toJsonSchema(
+    inputSchema: JsonSchema.toJsonSchema(
       Schema.Struct({
-        contact: Type.Ref(TestSchema.ContactType).annotations({ title: 'Contact' }),
+        contact: Ref.Ref(TestSchema.ContactType).annotations({ title: 'Contact' }),
       }),
     ),
   },

package/src/testing.ts

@@ -0,0 +1,7 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+// Eager re-export of `AutomationPlugin`. See `@dxos/plugin-testing/src/core.ts`
+// for the rationale.
+export * from './AutomationPlugin';