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

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

@@ -0,0 +1,9 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+// TODO(wittjosiah): Factor out.
+export * from './useComputeRuntimeCallback';
+export * from './useTriggerRuntimeControls';
+export * from './useComputeRuntime';
+export * from './useComputeRuntimeService';

package/src/hooks/useComputeRuntime.ts

@@ -0,0 +1,30 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { useEffect } from 'react';
+
+import { useCapabilities } from '@dxos/app-framework/ui';
+import { SpaceId } from '@dxos/keys';
+import { log } from '@dxos/log';
+
+import { AutomationCapabilities } from '../types';
+
+/**
+ * Resolves the compute runtime for a space.
+ * Returns undefined if the AutomationPlugin is not loaded or spaceId is not provided.
+ */
+export const useComputeRuntime = (id: SpaceId | undefined): AutomationCapabilities.ComputeRuntime | undefined => {
+  const [computeRuntime] = useCapabilities(AutomationCapabilities.ComputeRuntime);
+  // One log per change of (capability availability, spaceId) so we can see when
+  // the React subscription actually observes the contributed runtime.
+  useEffect(() => {
+    log('useComputeRuntime', { hasCapability: !!computeRuntime, spaceId: id });
+  }, [!!computeRuntime, id]);
+
+  if (!computeRuntime || id === undefined) {
+    return undefined;
+  }
+
+  return computeRuntime.getRuntime(id);
+};

package/src/hooks/useComputeRuntimeCallback.ts

@@ -0,0 +1,32 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+import { type DependencyList, useCallback } from 'react';
+
+import { type Key } from '@dxos/echo';
+
+import { AutomationCapabilities } from '#types';
+
+import { useComputeRuntime } from './useComputeRuntime';
+
+/**
+ * Create an effectful function that has access to compute services
+ */
+// TODO(burdon): Factor out (figure out cross-plugin capabilities dependencies).
+export const useComputeRuntimeCallback = <T>(
+  id: Key.SpaceId | undefined,
+  fn: () => Effect.Effect<T, any, AutomationCapabilities.ComputeServices>,
+  deps?: DependencyList,
+): (() => Promise<T>) => {
+  const runtime = useComputeRuntime(id);
+
+  return useCallback(() => {
+    if (!runtime) {
+      throw new TypeError('Space not provided to useComputeRuntimeCallback');
+    }
+
+    return runtime.runPromise(fn());
+  }, [runtime, ...(deps ?? [])]);
+};

package/src/hooks/useComputeRuntimeService.ts

@@ -0,0 +1,64 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Context from 'effect/Context';
+import * as Effect from 'effect/Effect';
+import * as Exit from 'effect/Exit';
+import { useEffect, useState } from 'react';
+
+import { SpaceId } from '@dxos/keys';
+import { log } from '@dxos/log';
+
+import { useComputeRuntime } from './useComputeRuntime';
+
+type ResolvedService<T extends Context.Tag<any, any>> = Context.Tag.Service<T> | undefined;
+
+/**
+ * Resolves a service from the compute runtime for a given space.
+ *
+ * NOTE: Previously implemented via `use(useMemo(() => runtime.runPromiseExit(...)))`.
+ * React's `use()` is weird and unreliable in production builds — the Suspense
+ * boundary can stay pending indefinitely without the promise ever resolving
+ * from React's perspective (the runtime is built lazily on first invocation
+ * and one of its `acquire` steps can block). This `useState` + `useEffect`
+ * flavour avoids suspension entirely: the hook returns `undefined` while the
+ * service is being acquired or if acquisition fails / times out.
+ */
+export const useComputeRuntimeService = <T extends Context.Tag<any, any>>(
+  tag: T,
+  spaceId?: SpaceId,
+): ResolvedService<T> => {
+  const runtime = useComputeRuntime(spaceId);
+  const [service, setService] = useState<ResolvedService<T>>(undefined);
+
+  useEffect(() => {
+    setService(undefined);
+    if (!runtime) {
+      return;
+    }
+    let cancelled = false;
+    void (async () => {
+      try {
+        const exit = await runtime.runPromiseExit(tag.pipe(Effect.timeout('30 seconds')));
+        if (cancelled) {
+          return;
+        }
+        if (Exit.isSuccess(exit)) {
+          setService(exit.value);
+        } else {
+          log.warn('useComputeRuntimeService: failed to acquire service', { cause: exit.cause });
+        }
+      } catch (error) {
+        if (!cancelled) {
+          log.catch(error);
+        }
+      }
+    })();
+    return () => {
+      cancelled = true;
+    };
+  }, [runtime, tag]);
+
+  return service;
+};

package/src/hooks/useTriggerRuntimeControls.ts

@@ -0,0 +1,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 { type Database, Filter, Query } from '@dxos/echo';
+import { Trigger } from '@dxos/functions';
+import { TriggerDispatcher, type TriggerDispatcherState } from '@dxos/functions-runtime';
+import { useQuery } from '@dxos/react-client/echo';
+
+import { useComputeRuntimeCallback } from './useComputeRuntimeCallback';
+
+interface TriggerRuntimeControls {
+  triggers: Trigger.Trigger[];
+
+  state: TriggerDispatcherState | undefined;
+
+  start: () => void;
+  stop: () => void;
+}
+
+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 init = useComputeRuntimeCallback(
+    db?.spaceId,
+    Effect.fnUntraced(function* () {
+      const dispatcher = yield* TriggerDispatcher;
+      setDispatcher(dispatcher);
+    }),
+  );
+
+  useEffect(() => {
+    void init();
+  }, []);
+
+  const state = useAtomValue(dispatcher?.state ?? Atom.make(undefined));
+
+  const start = useComputeRuntimeCallback(
+    db?.spaceId,
+    Effect.fnUntraced(function* () {
+      const dispatcher = yield* TriggerDispatcher;
+      yield* dispatcher.start();
+    }),
+  );
+
+  const stop = useComputeRuntimeCallback(
+    db?.spaceId,
+    Effect.fnUntraced(function* () {
+      const dispatcher = yield* TriggerDispatcher;
+      yield* dispatcher.stop();
+    }),
+  );
+
+  return {
+    triggers,
+    state,
+    start: () => void start(),
+    stop: () => void stop(),
+  };
+};

package/src/index.ts

@@ -2,7 +2,5 @@
 // Copyright 2023 DXOS.org
 //
 
-export * from './components';
-export * from './meta';
-
-export * from './AutomationPlugin';
+export { AutomationPlugin } from './AutomationPlugin';
+export { meta } from './meta';

package/src/meta.ts

@@ -2,15 +2,16 @@
 // 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 AUTOMATION_PLUGIN = 'dxos.org/plugin/automation';
-
-export const meta: PluginMeta = {
-  id: AUTOMATION_PLUGIN,
+export const meta: Plugin.Meta = {
+  id: 'org.dxos.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.',
-  icon: 'ph--robot--regular',
+  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--atom--regular',
   source: 'https://github.com/dxos/dxos/tree/main/packages/plugins/plugin-automation',
 };

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

@@ -0,0 +1,72 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { LayoutOperation, getSpacePath } from '@dxos/app-toolkit';
+import { Obj, Ref } from '@dxos/echo';
+import { Script, Trigger } from '@dxos/functions';
+import { type DXN } from '@dxos/keys';
+import { Operation } from '@dxos/operation';
+import { SpaceOperation } from '@dxos/plugin-space/operations';
+import { Filter } from '@dxos/react-client/echo';
+
+import { meta } from '#meta';
+
+import { CreateTriggerFromTemplate } from './definitions';
+
+const handler: Operation.WithHandler<typeof CreateTriggerFromTemplate> = 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/definitions.ts

@@ -0,0 +1,28 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Schema from 'effect/Schema';
+
+import { Capability } from '@dxos/app-framework';
+import { Database } from '@dxos/echo';
+import { Operation } from '@dxos/operation';
+
+import { meta } from '#meta';
+
+import { TriggerTemplate } from '../types';
+
+const AUTOMATION_OPERATION = `${meta.id}.operation`;
+
+export const CreateTriggerFromTemplate = Operation.make({
+  meta: { key: `${AUTOMATION_OPERATION}.create-trigger-from-template`, name: 'Create Trigger From Template' },
+  services: [Capability.Service],
+  input: Schema.Struct({
+    db: Database.Database,
+    template: TriggerTemplate,
+    enabled: Schema.optional(Schema.Boolean),
+    scriptName: Schema.optional(Schema.String),
+    input: Schema.optional(Schema.Record({ key: Schema.String, value: Schema.Any })),
+  }),
+  output: Schema.Void,
+});

package/src/operations/index.ts

@@ -0,0 +1,9 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { OperationHandlerSet } from '@dxos/operation';
+
+export * as AutomationOperation from './definitions';
+
+export const AutomationOperationHandlerSet = OperationHandlerSet.lazy(() => import('./create-trigger-from-template'));

package/src/testing/test-functions.ts

@@ -2,16 +2,17 @@
 // 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';
+import { TestSchema } from '@dxos/client/testing';
+import { JsonSchema, Ref } from '@dxos/echo';
 
 export const functions = [
   {
+    key: 'example.com/function/chess',
     name: 'example.com/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 = [
     ),
   },
   {
+    key: 'example.com/function/forex',
     name: 'example.com/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 = [
     ),
   },
   {
+    key: 'example.com/function/ping-contact',
     name: 'example.com/function/ping-contact',
     version: '0.0.1',
-    inputSchema: Type.toJsonSchema(
+    inputSchema: JsonSchema.toJsonSchema(
       Schema.Struct({
-        contact: Type.Ref(ContactType).annotations({ title: 'Contact' }),
+        contact: Ref.Ref(TestSchema.ContactType).annotations({ title: 'Contact' }),
       }),
     ),
   },

package/src/translations.ts

@@ -4,40 +4,50 @@
 
 import { type Resource } from '@dxos/react-ui';
 
-import { meta } from './meta';
+import { meta } from '#meta';
 
 export const translations = [
   {
     'en-US': {
       [meta.id]: {
-        'plugin name': 'Automation',
-        'automation panel label': 'Automations',
-        'script automation label': 'Automation',
-        'automation verbose label': 'Manage automations',
-        'automation description': 'You can manage all the triggers which automate your space here.',
-
-        'functions panel label': 'Functions',
-        'functions verbose label': 'Manage deployed functions',
-        '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',
-
-        'trigger editor title': 'Configure Trigger',
-        'new trigger label': 'Add Trigger',
-        'trigger type timer': 'Timer',
-        'trigger type webhook': 'Webhook',
-        'trigger type websocket': 'Websocket',
-        'trigger type subscription': 'Subscription',
-        'trigger type email': 'Email',
-        'trigger type queue': 'Queue',
-
-        'trigger copy url': 'Copy URL',
-        'trigger copy email': 'Copy Email',
-
-        'trigger payload add': 'Add',
-        'trigger payload remove': 'Remove',
-        'trigger payload prop name placeholder': 'New payload property name',
+        'plugin.name': 'Automation',
+        'automation-panel.label': 'Automations',
+        'script-automation.label': 'Automation',
+        'automation-verbose.label': 'Manage automations',
+        'automation.description': 'Triggers that automate this space.',
+
+        'runtime.label': 'Trigger runtime location',
+        'runtime.description': 'Determines where the triggers in this space will execute.',
+        'runtime.disabled.label': 'Triggers disabled',
+        'runtime.local.label': 'Local',
+        'runtime.edge.label': 'EDGE (experimental)',
+
+        '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': 'Functions deployed from this space on EDGE.',
+        'show-source-button.label': 'Show source',
+        'delete-function-button.label': 'Delete function',
+
+        'function-parameters.label': 'Function parameters',
+
+        'trigger-editor.title': 'Configure Trigger',
+        'trigger-editor.description':
+          'Triggers are used to run functions at specific times or when specific events occur.',
+        'new-trigger.label': 'Add Trigger',
+
+        'trigger-type.timer.label': 'Timer',
+        'trigger-type.webhook.label': 'Webhook',
+        'trigger-type.websocket.label': 'Websocket',
+        'trigger-type.subscription.label': 'Subscription',
+        'trigger-type.email.label': 'Email',
+        'trigger-type.queue.label': 'Feed',
+
+        'trigger-payload-prop-name.placeholder': 'New payload property name',
+        'import-function-button.label': 'Loading...',
+        'update-function-button.label': 'Update',
+        'loading-functions.message': 'Loading functions...',
       },
     },
   },

package/src/types/capabilities.ts

@@ -0,0 +1,48 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import type * as ManagedRuntime from 'effect/ManagedRuntime';
+
+import { type AiService, type OpaqueToolkit } from '@dxos/ai';
+import { Capability } from '@dxos/app-framework';
+import type { Blueprint } from '@dxos/blueprints';
+import { type Database, type Feed } from '@dxos/echo';
+import type { CredentialsService, Process, QueueService } from '@dxos/functions';
+import { AgentService } from '@dxos/functions-runtime';
+import type { ProcessManager, TriggerDispatcher, TriggerStateStore } from '@dxos/functions-runtime';
+import type { SpaceId } from '@dxos/keys';
+import type { Operation, OperationRegistry } from '@dxos/operation';
+
+import { meta } from '#meta';
+
+export namespace AutomationCapabilities {
+  /**
+   * Service stack for executing agents, functions, and triggers.
+   */
+  export type ComputeServices =
+    | TriggerDispatcher
+    | TriggerStateStore
+    | AiService.AiService
+    | Database.Service
+    | Feed.FeedService
+    | QueueService
+    | CredentialsService
+    | Blueprint.RegistryService
+    | AgentService.AgentService
+    | Process.ProcessMonitorService
+    | ProcessManager.Service
+    | Operation.Service
+    | OperationRegistry.Service
+    | OpaqueToolkit.OpaqueToolkitProvider;
+
+  export type ComputeRuntime = ManagedRuntime.ManagedRuntime<AutomationCapabilities.ComputeServices, never>;
+  export interface ComputeRuntimeProvider {
+    getRuntime(spaceId: SpaceId): ComputeRuntime;
+  }
+
+  /**
+   * Runtime for executing agents, functions, and triggers.
+   */
+  export const ComputeRuntime = Capability.make<ComputeRuntimeProvider>(`${meta.id}.capability.compute-runtime`);
+}

package/src/types/events.ts

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