@dxos/plugin-automation 0.8.4-main.f9ba587 → 0.8.4-main.fffef41

package/src/components/TriggerEditor/FunctionInputEditor.tsx

@@ -5,13 +5,13 @@
 import React, { useCallback, useMemo } from 'react';
 
 import { Ref, Type } from '@dxos/echo';
-import { type JsonPath } from '@dxos/echo-schema';
-import { type FunctionType } from '@dxos/functions';
+import { type JsonPath } from '@dxos/echo/internal';
+import { type Function } from '@dxos/functions';
 import { useOnTransition } from '@dxos/react-ui';
 import { Form, type FormInputStateProps, type QueryRefOptions, useFormValues } from '@dxos/react-ui-form';
 
 export type FunctionInputEditorProps = {
-  functions: FunctionType[];
+  functions: Function.Function[];
   onQueryRefOptions: QueryRefOptions;
 } & FormInputStateProps;
 
@@ -39,7 +39,13 @@ export const FunctionInputEditor = ({
   useOnTransition(
     // Clear function parameter input when the function changes.
     selectedFunctionValue,
-    (prevValue) => prevValue !== undefined && prevValue !== selectedFunctionValue,
+    (prevValue) => {
+      if (!Ref.isRef(prevValue) || !Ref.isRef(selectedFunctionValue)) {
+        return false;
+      }
+
+      return prevValue.dxn.toString() !== selectedFunctionValue.dxn.toString();
+    },
     (currValue) => currValue !== undefined,
     () => onValueChange('object', {}),
   );

package/src/components/TriggerEditor/SpecSelector.tsx

@@ -4,32 +4,38 @@
 
 import React, { useCallback, useMemo } from 'react';
 
-import { type FunctionTriggerType, TriggerKind, type TriggerType } from '@dxos/functions';
+import { Filter, Query } from '@dxos/echo';
+import { Trigger } from '@dxos/functions';
 import { useTranslation } from '@dxos/react-ui';
-import { SelectInput, type InputProps, useInputProps } from '@dxos/react-ui-form';
+import { type InputProps, SelectInput, useInputProps } from '@dxos/react-ui-form';
 
-import { AUTOMATION_PLUGIN } from '../../meta';
+import { meta } from '../../meta';
 
 export type SpecSelectorProps = InputProps;
 
 export const SpecSelector = (props: SpecSelectorProps) => {
-  const { t } = useTranslation(AUTOMATION_PLUGIN);
-  const specProps = useInputProps(['spec' satisfies keyof FunctionTriggerType]);
+  const { t } = useTranslation(meta.id);
+  const specProps = useInputProps(['spec' satisfies keyof Trigger.Trigger]);
 
   const handleTypeChange = useCallback(
-    (_type: any, value: string): TriggerType | undefined => {
+    (_type: any, value: string): Trigger.Spec | undefined => {
       const getDefaultTriggerSpec = (kind: string) => {
         switch (kind) {
-          case TriggerKind.Timer:
-            return { kind: TriggerKind.Timer, cron: '' };
-          case TriggerKind.Subscription:
-            return { kind: TriggerKind.Subscription, filter: {} };
-          case TriggerKind.Queue:
-            return { kind: TriggerKind.Queue, queue: '' };
-          case TriggerKind.Email:
-            return { kind: TriggerKind.Email };
-          case TriggerKind.Webhook:
-            return { kind: TriggerKind.Webhook };
+          case 'timer':
+            return { kind: 'timer', cron: '' };
+          case 'subscription':
+            return {
+              kind: 'subscription',
+              query: {
+                ast: Query.select(Filter.nothing()).ast,
+              },
+            };
+          case 'queue':
+            return { kind: 'queue', queue: 'dxn:' };
+          case 'email':
+            return { kind: 'email' };
+          case 'webhook':
+            return { kind: 'webhook' };
           default:
             return undefined;
         }
@@ -48,7 +54,7 @@ export const SpecSelector = (props: SpecSelectorProps) => {
 
   const options = useMemo(
     () =>
-      Object.values(TriggerKind).map((kind) => ({
+      Trigger.Kinds.map((kind) => ({
         value: kind,
         label: t(`trigger type ${kind}`),
       })),

package/src/components/TriggerEditor/TriggerEditor.stories.tsx

@@ -2,32 +2,56 @@
 // Copyright 2025 DXOS.org
 //
 
-import '@dxos-theme';
+import { type Meta, type StoryObj } from '@storybook/react-vite';
+import React, { useState } from 'react';
 
-import { type Meta } from '@storybook/react-vite';
-import React, { useEffect, useState } from 'react';
-
-import { Obj } from '@dxos/echo';
-import { FunctionType, FunctionTrigger, TriggerKind } from '@dxos/functions';
+import { Filter, Obj, Ref, Tag, Type } from '@dxos/echo';
+import { Function } from '@dxos/functions';
+import { Trigger } from '@dxos/functions';
+import { invariant } from '@dxos/invariant';
 import { faker } from '@dxos/random';
-import { useSpaces } from '@dxos/react-client/echo';
-import { ContactType, withClientProvider } from '@dxos/react-client/testing';
-import { withLayout, withTheme } from '@dxos/storybook-utils';
+import { useQuery } from '@dxos/react-client/echo';
+import { ContactType, useClientProvider, withClientProvider } from '@dxos/react-client/testing';
+import { useAsyncEffect } from '@dxos/react-ui';
+import { withLayout, withTheme } from '@dxos/react-ui/testing';
+import { Employer, Organization, Person, Project } from '@dxos/types';
 
-import { TriggerEditor } from './TriggerEditor';
 import { functions } from '../../testing';
 import { translations } from '../../translations';
 
-const DefaultStory = () => {
-  const spaces = useSpaces();
-  const space = spaces[1];
-  const [trigger, setTrigger] = useState<FunctionTrigger>();
-  useEffect(() => {
+import { TriggerEditor, type TriggerEditorProps } from './TriggerEditor';
+
+const types = [
+  // TODO(burdon): Get label from annotation.
+  { value: Organization.Organization.typename, label: 'Organization' },
+  { value: Person.Person.typename, label: 'Person' },
+  { value: Type.getTypename(Project.Project), label: 'Project' },
+  { value: Employer.Employer.typename, label: 'Employer' },
+];
+
+const DefaultStory = (props: Partial<TriggerEditorProps>) => {
+  const { space } = useClientProvider();
+  const [trigger, setTrigger] = useState<Trigger.Trigger>();
+  const tags = useQuery(space, Filter.type(Tag.Tag));
+
+  useAsyncEffect(async () => {
     if (!space) {
       return;
     }
 
-    const trigger = space.db.add(Obj.make(FunctionTrigger, { spec: { kind: TriggerKind.Timer, cron: '' } }));
+    const result = await space.db.query(Filter.type(Function.Function)).run();
+    const fn = result.objects.find((fn) => fn.name === 'example.com/function/forex');
+    invariant(fn);
+    const trigger = space.db.add(
+      Trigger.make({
+        function: Ref.make(fn),
+        spec: { kind: 'webhook' },
+        input: {
+          from: 'USD',
+          to: 'JPY',
+        },
+      }),
+    );
     setTrigger(trigger);
   }, [space]);
 
@@ -36,24 +60,37 @@ const DefaultStory = () => {
   }
 
   return (
-    <div role='none' className='w-[32rem] bs-fit border border-separator rounded-sm'>
-      <TriggerEditor space={space} trigger={trigger} onSave={(values) => console.log('on save', values)} />
+    <div role='none' className='is-[32rem] bs-fit border border-separator rounded-sm'>
+      <TriggerEditor
+        space={space}
+        trigger={trigger}
+        types={types}
+        tags={tags}
+        onSave={(values) => console.log('on save', values)}
+        {...props}
+      />
     </div>
   );
 };
 
-const meta: Meta = {
+const meta = {
   title: 'plugins/plugin-automation/TriggerEditor',
-  component: TriggerEditor,
+  component: TriggerEditor as any,
   render: DefaultStory,
   decorators: [
+    withTheme,
+    withLayout({ container: 'column' }),
     withClientProvider({
       createIdentity: true,
       createSpace: true,
-      types: [FunctionType, FunctionTrigger, ContactType],
-      onSpaceCreated: ({ space }) => {
+      types: [Tag.Tag, Function.Function, Trigger.Trigger, ContactType],
+      onCreateSpace: ({ space }) => {
+        space.db.add(Tag.make({ label: 'Important' }));
+        space.db.add(Tag.make({ label: 'Investor' }));
+        space.db.add(Tag.make({ label: 'New' }));
+
         for (const fn of functions) {
-          space.db.add(Obj.make(FunctionType, fn));
+          space.db.add(Function.make(fn));
         }
         Array.from({ length: 10 }).map(() => {
           return space.db.add(
@@ -65,14 +102,20 @@ const meta: Meta = {
         });
       },
     }),
-    withLayout({ fullscreen: true, classNames: 'flex justify-center m-2' }),
-    withTheme,
   ],
   parameters: {
     translations,
   },
-};
+} satisfies Meta<typeof DefaultStory>;
 
 export default meta;
 
-export const Default = {};
+type Story = StoryObj<typeof meta>;
+
+export const Default: Story = {};
+
+export const ReadonlySpec: Story = {
+  args: {
+    readonlySpec: true,
+  },
+};

package/src/components/TriggerEditor/TriggerEditor.tsx

@@ -5,40 +5,38 @@
 import React, { useCallback, useMemo } from 'react';
 
 import { ComputeGraph } from '@dxos/conductor';
-import { Type } from '@dxos/echo';
-import {
-  FunctionType,
-  FunctionTriggerSchema,
-  type FunctionTriggerType,
-  type FunctionTrigger,
-  ScriptType,
-} from '@dxos/functions';
-import { Filter, Ref, useQuery, type Space } from '@dxos/react-client/echo';
-import { type CustomInputMap, Form, SelectInput, useRefQueryLookupHandler } from '@dxos/react-ui-form';
+import { type Query, Type } from '@dxos/echo';
+import { Function, Script, Trigger } from '@dxos/functions';
+import { Filter, Ref, type Space, 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 { SpecSelector } from './SpecSelector';
 
 export type TriggerEditorProps = {
   space: Space;
-  trigger: FunctionTriggerType;
-  onSave?: (trigger: Omit<FunctionTrigger, 'id'>) => void;
+  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, onSave, onCancel }: TriggerEditorProps) => {
-  const handleSave = (values: FunctionTriggerType) => {
+export const TriggerEditor = ({ space, trigger, readonlySpec, types, tags, onSave, onCancel }: TriggerEditorProps) => {
+  const handleSave = ({ id: _, ...values }: Trigger.Trigger) => {
     onSave?.(values);
   };
 
   const handleRefQueryLookup = useRefQueryLookupHandler({ space });
-  const Custom = useCustomInputs(space, handleRefQueryLookup);
+  const Custom = useCustomInputs({ space, readonlySpec, types, tags, onQueryRefOptions: handleRefQueryLookup });
 
   return (
     <Form
       outerSpacing={false}
       Custom={Custom}
-      schema={FunctionTriggerSchema}
+      schema={Trigger.Trigger}
       values={trigger}
       onSave={handleSave}
       onCancel={onCancel}
@@ -47,15 +45,21 @@ export const TriggerEditor = ({ space, trigger, onSave, onCancel }: TriggerEdito
   );
 };
 
-const useCustomInputs = (space: Space, onQueryRefOptions: FunctionInputEditorProps['onQueryRefOptions']) => {
-  const functions = useQuery(space, Filter.type(FunctionType));
+type UseCustomInputsProps = {
+  space: Space;
+  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(ScriptType));
+  const scripts = useQuery(space, Filter.type(Script.Script));
 
   return useMemo(
     (): CustomInputMap => ({
       // Function selector.
-      ['function' satisfies keyof FunctionTriggerType]: (props) => {
+      ['function' satisfies keyof Trigger.Trigger]: (props) => {
         const getValue = useCallback(() => {
           const formValue = props.getValue();
           if (Ref.isRef(formValue)) {
@@ -86,14 +90,30 @@ const useCustomInputs = (space: Space, onQueryRefOptions: FunctionInputEditorPro
       },
 
       // Spec selector.
-      ['spec.kind' as const]: SpecSelector,
+      ['spec.kind' as const]: (props) => <SpecSelector {...props} readonly={readonlySpec ? 'disabled-input' : false} />,
+
+      // TODO(wittjosiah): Copied from ViewEditor.
+      // Query input editor.
+      ['spec.query' as const]: (props) => {
+        const handleChange = useCallback(
+          (query: Query.Any) => props.onValueChange('object', { ast: query.ast }),
+          [props.onValueChange],
+        );
+
+        return (
+          <Input.Root>
+            <InputHeader label={props.label} />
+            <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} />
       ),
     }),
-    [workflows, scripts, functions],
+    [workflows, scripts, functions, readonlySpec],
   );
 };
 
@@ -101,7 +121,7 @@ const getWorkflowOptions = (graphs: ComputeGraph[]) => {
   return graphs.map((graph) => ({ label: `compute-${graph.id}`, value: `dxn:echo:@:${graph.id}` }));
 };
 
-const getFunctionOptions = (scripts: ScriptType[], functions: FunctionType[]) => {
-  const getLabel = (fn: FunctionType) => scripts.find((s) => fn.source?.target?.id === s.id)?.name ?? fn.name;
+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;
   return functions.map((fn) => ({ label: getLabel(fn), value: `dxn:echo:@:${fn.id}` }));
 };

package/src/components/TriggerSettings.tsx

@@ -0,0 +1,25 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import React from 'react';
+
+import { type Space } from '@dxos/react-client/echo';
+import { Input, useTranslation } from '@dxos/react-ui';
+import { ControlItemInput } from '@dxos/react-ui-form';
+
+import { useTriggerRuntimeControls } from '../hooks';
+import { meta } from '../meta';
+
+export const TriggersSettings = ({ space }: { space: Space }) => {
+  const { triggers, isRunning, start, stop } = useTriggerRuntimeControls(space);
+  const { t } = useTranslation(meta.id);
+
+  return (
+    <div className='container-max-width grid grid-cols-1 md:grid-cols-[1fr_min-content]'>
+      <ControlItemInput title={t('runtime label')} description={t('runtime description')}>
+        <Input.Switch classNames='justify-self-end' checked={isRunning} onCheckedChange={isRunning ? stop : start} />
+      </ControlItemInput>
+    </div>
+  );
+};

package/src/components/index.ts

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

package/src/events.ts

@@ -0,0 +1,11 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { defineEvent } from '@dxos/app-framework';
+
+import { meta } from './meta';
+
+export namespace AutomationEvents {
+  export const ComputeRuntimeReady = defineEvent(`${meta.id}/event/compute-runtime-ready`);
+}

package/src/hooks/index.ts

@@ -0,0 +1,6 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+export * from './useComputeRuntimeCallback';
+export * from './useTriggerRuntimeControls';

package/src/hooks/useComputeRuntimeCallback.ts

@@ -0,0 +1,68 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Cause from 'effect/Cause';
+import * as Effect from 'effect/Effect';
+import * as Exit from 'effect/Exit';
+import { useCallback } from 'react';
+
+import { useCapability } from '@dxos/app-framework/react';
+import { type FunctionDefinition, FunctionInvocationService } from '@dxos/functions';
+import { InvocationTracer, TracingServiceExt } from '@dxos/functions-runtime';
+import { log } from '@dxos/log';
+import type { Space } from '@dxos/react-client/echo';
+
+import { AutomationCapabilities } from '../capabilities';
+
+/**
+ * Create an effectful function that has access to compute services
+ */
+// TODO(burdon): Factor out (figure out cross-plugin capabilities dependencies).
+export const useComputeRuntimeCallback = <T>(
+  space: Space | undefined,
+  fn: () => Effect.Effect<T, any, AutomationCapabilities.ComputeServices>,
+  deps?: React.DependencyList,
+): (() => Promise<T>) => {
+  const computeRuntime = useCapability(AutomationCapabilities.ComputeRuntime);
+  const runtime = space !== undefined ? computeRuntime.getRuntime(space.id) : undefined;
+
+  return useCallback(() => {
+    if (!runtime) {
+      throw new TypeError('Space not provided to useComputeRuntimeCallback');
+    }
+
+    return runtime.runPromise(fn());
+  }, [runtime, ...(deps ?? [])]);
+};
+
+// TODO(wittjosiah): Function invoking should automatically be traced (DX-647).
+export const invokeFunctionWithTracing = <I, O>(functionDef: FunctionDefinition<I, O>, inputData: I) =>
+  Effect.gen(function* () {
+    const tracer = yield* InvocationTracer;
+    const trace = yield* tracer.traceInvocationStart({
+      target: undefined,
+      payload: {
+        data: {},
+      },
+    });
+
+    // Invoke the function.
+    const result = yield* FunctionInvocationService.invokeFunction(functionDef, inputData).pipe(
+      Effect.provide(TracingServiceExt.layerQueue(trace.invocationTraceQueue)),
+      Effect.exit,
+    );
+
+    if (Exit.isFailure(result)) {
+      const error = Cause.prettyErrors(result.cause)[0];
+      log.error(error.message, error.cause ?? error.stack);
+    }
+
+    yield* tracer.traceInvocationEnd({
+      trace,
+      // TODO(dmaretskyi): Might miss errors.
+      exception: Exit.isFailure(result) ? Cause.prettyErrors(result.cause)[0] : undefined,
+    });
+
+    return result;
+  });

package/src/hooks/useTriggerRuntimeControls.ts

@@ -0,0 +1,53 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+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';
+
+interface TriggerRuntimeControls {
+  triggers: Trigger.Trigger[];
+  isRunning: boolean;
+  start: () => void;
+  stop: () => void;
+}
+
+export const useTriggerRuntimeControls = (space: Space | undefined): TriggerRuntimeControls => {
+  const triggers = useQuery(space, Filter.type(Trigger.Trigger));
+
+  const [isRunningState, setIsRunningState] = useAsyncState(
+    useComputeRuntimeCallback(space, () => TriggerDispatcher.pipe(Effect.map((t) => t.running))),
+  );
+
+  const start = useComputeRuntimeCallback(
+    space,
+    Effect.fnUntraced(function* () {
+      const dispatcher = yield* TriggerDispatcher;
+      yield* dispatcher.start();
+      setIsRunningState(true);
+    }),
+  );
+
+  const stop = useComputeRuntimeCallback(
+    space,
+    Effect.fnUntraced(function* () {
+      const dispatcher = yield* TriggerDispatcher;
+      yield* dispatcher.stop();
+      setIsRunningState(false);
+    }),
+  );
+
+  return {
+    triggers,
+    isRunning: isRunningState ?? false,
+    start: () => void start(),
+    stop: () => void stop(),
+  };
+};

package/src/index.ts

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

package/src/meta.ts

@@ -3,14 +3,15 @@
 //
 
 import { type PluginMeta } from '@dxos/app-framework';
-
-export const AUTOMATION_PLUGIN = 'dxos.org/plugin/automation';
+import { trim } from '@dxos/util';
 
 export const meta: PluginMeta = {
-  id: AUTOMATION_PLUGIN,
+  id: 'dxos.org/plugin/automation',
   name: 'Automation',
-  description:
-    'The Automation tab allows you to trigger pre-defined workflows related to the element you are interacting with inside of Composer.',
+  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',
   source: 'https://github.com/dxos/dxos/tree/main/packages/plugins/plugin-automation',
 };

package/src/testing/test-functions.ts

@@ -2,7 +2,7 @@
 // Copyright 2024 DXOS.org
 //
 
-import { Schema } from 'effect';
+import * as Schema from 'effect/Schema';
 
 import { ContactType } from '@dxos/client/testing';
 import { Type } from '@dxos/echo';

package/src/translations.ts

@@ -16,12 +16,19 @@ export const translations = [
         'automation verbose label': 'Manage automations',
         'automation description': 'You can manage all the triggers which automate your space here.',
 
+        'runtime label': 'Enable Local Runtime',
+        'runtime description':
+          'This will start a trigger dispatcher locally for this space to run triggers on your device while Composer is running.',
+
         'functions panel label': 'Functions',
         'functions verbose label': 'Manage deployed functions',
+        'functions registry verbose label': 'Functions registry',
+        'functions registry description': 'Import functions from the registry',
         'functions description': 'You can manage all the functions deployed from your space on EDGE here.',
         'function copy id': 'Copy Function ID',
         'no functions found': 'No functions found',
         'go to function source button label': 'Show function source',
+        'delete function button label': 'Delete function',
 
         'trigger editor title': 'Configure Trigger',
         'new trigger label': 'Add Trigger',

package/src/types/index.ts

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

package/src/{types.ts → types/schema.ts}

@@ -2,11 +2,11 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Schema } from 'effect';
+import * as Schema from 'effect/Schema';
 
 import { SpaceSchema } from '@dxos/react-client/echo';
 
-import { AUTOMATION_PLUGIN } from './meta';
+import { meta } from '../meta';
 
 const TriggerTemplate = Schema.Union(
   Schema.Struct({ type: Schema.Literal('timer'), cron: Schema.String }),
@@ -14,10 +14,8 @@ const TriggerTemplate = Schema.Union(
 );
 
 export namespace AutomationAction {
-  const AUTOMATION_ACTION = `${AUTOMATION_PLUGIN}/action`;
-
   export class CreateTriggerFromTemplate extends Schema.TaggedClass<CreateTriggerFromTemplate>()(
-    `${AUTOMATION_ACTION}/create-trigger-from-template`,
+    `${meta.id}/action/create-trigger-from-template`,
     {
       input: Schema.Struct({
         space: SpaceSchema,