@dxos/plugin-automation 0.8.4-main.c85a9c8dae → 0.8.4-main.d9fc60f731

package/src/{cli/commands → commands}/trigger/util.ts

@@ -12,10 +12,11 @@ import type * as Schema from 'effect/Schema';
 import * as SchemaAST from 'effect/SchemaAST';
 
 import { FormBuilder } from '@dxos/cli-util';
-import { Annotation, Database, Entity, Filter, Obj, Ref, Type } from '@dxos/echo';
+import { Operation, Trigger } from '@dxos/compute';
+// eslint-disable-next-line unused-imports/no-unused-imports
+import { Annotation, Database, Entity, Feed, Filter, Obj, Query, type QueryAST, Ref, Scope, Type } from '@dxos/echo';
 import { getProperties } from '@dxos/effect';
-import { Function, Trigger } from '@dxos/functions';
-import { QueueAnnotation } from '@dxos/schema';
+import { FeedAnnotation } from '@dxos/schema';
 
 export type TriggerRemoteStatus = 'available' | 'not available' | 'n/a';
 
@@ -60,7 +61,10 @@ export const printTrigger = Effect.fn(function* (trigger: Trigger.Trigger, remot
       fn,
       FormBuilder.nest(
         'function',
-        FormBuilder.make().pipe(FormBuilder.set('key', fn!.key), FormBuilder.set('dxn', fn!.dxn?.toString())),
+        FormBuilder.make().pipe(
+          FormBuilder.set('key', Obj.getMeta(fn as Operation.PersistentOperation).key),
+          FormBuilder.set('dxn', Obj.getURI(fn as Obj.Unknown)),
+        ),
       ),
     ),
     FormBuilder.nestedOption('spec', Option.fromNullable(trigger.spec).pipe(Option.map(printSpec))),
@@ -76,8 +80,8 @@ const printSpec = <T extends Trigger.Spec>(spec: T): FormBuilder.FormBuilder =>
       return printSubscription(spec);
     case 'webhook':
       return printWebhook(spec);
-    case 'queue':
-      return printQueue(spec);
+    case 'feed':
+      return printFeed(spec);
     default:
       return FormBuilder.make({}).pipe(FormBuilder.set('unknown', 'Unknown spec type'));
   }
@@ -91,7 +95,8 @@ const printSubscription = (spec: Trigger.SubscriptionSpec) =>
 const printWebhook = (spec: Trigger.WebhookSpec) =>
   FormBuilder.make({}).pipe(FormBuilder.set('method', spec.method), FormBuilder.set('port', spec.port));
 
-const printQueue = (spec: Trigger.QueueSpec) => FormBuilder.make({}).pipe(FormBuilder.set('queue', spec.queue));
+const printFeed = (spec: Trigger.FeedSpec) =>
+  FormBuilder.make({}).pipe(FormBuilder.set('feed', spec.feed ? spec.feed.uri.toString() : '(none)'));
 
 /**
  * Prompts for input values based on an Effect schema.
@@ -272,7 +277,7 @@ export const promptForSchemaInput = Effect.fn(function* (
  * Queries the database for functions and prompts the user to select one.
  */
 export const selectFunction = Effect.fn(function* () {
-  const functions = yield* Database.runQuery(Filter.type(Function.Function));
+  const functions = yield* Database.runQuery(Filter.type(Operation.PersistentOperation));
 
   if (functions.length === 0) {
     return yield* Effect.fail(new Error('No functions available'));
@@ -280,7 +285,7 @@ export const selectFunction = Effect.fn(function* () {
 
   const selected = yield* Prompt.select({
     message: 'Select a function:',
-    choices: functions.map((fn: Function.Function) => ({
+    choices: functions.map((fn: Operation.PersistentOperation) => ({
       title: fn.name ?? fn.id,
       value: fn.id,
       description: fn.description,
@@ -296,7 +301,9 @@ export const selectFunction = Effect.fn(function* () {
  * Queries the database for triggers and prompts the user to select one.
  */
 export const selectTrigger = Effect.fn(function* (kind?: Trigger.Kind) {
-  const triggers = yield* Database.runQuery(Filter.type(Trigger.Trigger));
+  const triggers = yield* Database.runQuery(
+    Query.select(Filter.type(Trigger.Trigger)).debugLabel('cli.trigger.selectTrigger'),
+  );
   const filteredTriggers = kind ? triggers.filter((trigger) => trigger.spec?.kind === kind) : triggers;
 
   if (filteredTriggers.length === 0) {
@@ -307,7 +314,10 @@ export const selectTrigger = Effect.fn(function* (kind?: Trigger.Kind) {
     filteredTriggers.map((trigger) =>
       Effect.gen(function* () {
         const fn = trigger.function ? yield* Database.load(trigger.function) : undefined;
-        const functionName = fn && Obj.instanceOf(Function.Function, fn) ? (fn.name ?? fn.key ?? fn.id) : undefined;
+        const functionName =
+          fn && Obj.instanceOf(Operation.PersistentOperation, fn)
+            ? (fn.name ?? Obj.getMeta(fn).key ?? fn.id)
+            : undefined;
         const title = functionName ?? trigger.id;
         const description = `${trigger.enabled ? 'enabled' : 'disabled'} - ${trigger.spec?.kind ?? 'unknown'}`;
 
@@ -329,63 +339,68 @@ export const selectTrigger = Effect.fn(function* (kind?: Trigger.Kind) {
 });
 
 /**
- * Selects a queue interactively from available queues in the database.
- * Queries schemas with QueueAnnotation, then queries objects of those types,
- * and extracts queue DXNs from the objects' queue properties.
+ * Selects a feed interactively from available feeds in the database.
+ * Queries schemas with FeedAnnotation, then queries objects of those types,
+ * and returns the chosen Feed object.
  */
-export const selectQueue = Effect.fn(function* () {
-  // Query schema registry for schemas with QueueAnnotation
-  const schemas = yield* Database.runSchemaQuery({ location: ['database', 'runtime'] });
-
-  // Filter schemas that have QueueAnnotation
-  const queueSchemas = schemas.filter((schema) => {
-    const annotation = QueueAnnotation.get(schema);
+export const selectFeed = Effect.fn(function* () {
+  // Query schema registry for schemas with FeedAnnotation.
+  const schemas = yield* Database.runQuery(Query.select(Filter.type(Type.Type)).from(Scope.space(), Scope.registry()));
+
+  // Filter schemas that have FeedAnnotation.
+  const feedSchemas = schemas.filter((type) => {
+    const schema = Type.getSchema(type);
+    const annotation = FeedAnnotation.get(schema);
     return Option.isSome(annotation) && annotation.value === true;
   });
 
-  if (queueSchemas.length === 0) {
-    return yield* Effect.fail(new Error('No schemas with Queue annotation found'));
+  if (feedSchemas.length === 0) {
+    return yield* Effect.fail(new Error('No schemas with Feed annotation found'));
   }
 
-  // Collect all objects with queues
-  const queueChoices: Array<{ title: string; value: string; description?: string }> = [];
+  // Collect all Feed objects referenced by host objects.
+  const feedChoices: Array<{ title: string; value: Feed.Feed; description?: string }> = [];
 
-  // Process each schema, skipping ones that fail
-  for (const schema of queueSchemas) {
+  // Process each feed schema, resolving the Feed object reference.
+  for (const schema of feedSchemas) {
     yield* Effect.gen(function* () {
       const typename = Type.getTypename(schema);
       const objects = yield* Database.runQuery(Filter.type(typename));
 
       for (const obj of objects) {
-        // Access the queue property (which is a Ref<Queue>)
-        const queueRef = (obj as any).queue as Ref.Ref<any> | undefined;
-        if (!queueRef) {
+        // Access the feed property (which is a Ref<Feed>).
+        const feedRef = (obj as any).feed as Ref.Ref<any> | undefined;
+        if (!feedRef) {
+          continue;
+        }
+
+        const feedObj = yield* Effect.promise(() => feedRef.tryLoad());
+        if (!feedObj || !Obj.instanceOf(Feed.Feed, feedObj)) {
           continue;
         }
 
-        const queueDxn = queueRef.dxn.toString();
         const label = Obj.getLabel(obj) ?? obj.id;
         const description = Obj.getTypename(obj);
 
-        queueChoices.push({
+        feedChoices.push({
           title: label,
-          value: queueDxn,
+          value: feedObj,
           description,
         });
       }
     }).pipe(Effect.catchAll(() => Effect.void));
   }
 
-  if (queueChoices.length === 0) {
-    return yield* Effect.fail(new Error('No objects with queue properties found'));
+  if (feedChoices.length === 0) {
+    return yield* Effect.fail(new Error('No objects with feed properties found'));
   }
 
   const selected = yield* Prompt.select({
-    message: 'Select a queue:',
-    choices: queueChoices,
+    message: 'Select a feed:',
+    choices: feedChoices,
   });
 
-  return String(selected);
+  return selected as Feed.Feed;
 });
 
 /**

package/src/components/AutomationPanel/AutomationPanel.stories.tsx

@@ -5,13 +5,14 @@
 import { type Meta, type StoryObj } from '@storybook/react-vite';
 import React from 'react';
 
-import { Function, Trigger } from '@dxos/functions';
+import { Operation, Trigger } from '@dxos/compute';
+import { Obj } from '@dxos/echo';
 import { useSpaces } from '@dxos/react-client/echo';
 import { withClientProvider } from '@dxos/react-client/testing';
 import { withTheme } from '@dxos/react-ui/testing';
 
-import { functions } from '../../testing';
-import { translations } from '../../translations';
+import { functions } from '#testing';
+import { translations } from '#translations';
 
 import { AutomationPanel } from './AutomationPanel';
 
@@ -35,10 +36,16 @@ const meta = {
     withClientProvider({
       createIdentity: true,
       createSpace: true,
-      types: [Function.Function, Trigger.Trigger],
+      types: [Operation.PersistentOperation, Trigger.Trigger],
       onCreateSpace: ({ space }) => {
         for (const fn of functions) {
-          space.db.add(Function.make(fn));
+          const { key, version, ...data } = fn;
+          space.db.add(
+            Obj.make(Operation.PersistentOperation, {
+              [Obj.Meta]: { key, version: version ?? '0.1.0' },
+              ...data,
+            }),
+          );
         }
       },
     }),

package/src/components/AutomationPanel/AutomationPanel.tsx

@@ -3,16 +3,21 @@
 //
 
 import * as Array from 'effect/Array';
+import * as Effect from 'effect/Effect';
 import * as EFn from 'effect/Function';
 import * as Match from 'effect/Match';
 import * as Schema from 'effect/Schema';
 import React, { useCallback, useMemo, useState } from 'react';
 
-import { Filter, Obj, Tag } from '@dxos/echo';
-import { Function, Script, Trigger } from '@dxos/functions';
-import { KEY_QUEUE_CURSOR } from '@dxos/functions-runtime';
+import { useProcessManagerRuntime } from '@dxos/app-framework/ui';
+import { useTypeOptions } from '@dxos/app-toolkit/ui';
+import { type ComputeEnvironment } from '@dxos/client-protocol';
+import { Operation, Script, ServiceResolver, Trigger, TriggerEvent } from '@dxos/compute';
+import { Context } from '@dxos/context';
+import { Filter, Obj, Query, Tag, Type } from '@dxos/echo';
+import { KEY_FEED_CURSOR, TriggerDispatcher } from '@dxos/functions-runtime';
 import { FunctionsServiceClient } from '@dxos/functions-runtime/edge';
-import { useTypeOptions } from '@dxos/plugin-space';
+import { log } from '@dxos/log';
 import { type Client, useClient } from '@dxos/react-client';
 import { type Space, useObject, useQuery } from '@dxos/react-client/echo';
 import { Clipboard, IconButton, type IconButtonProps, Input, Separator, useTranslation } from '@dxos/react-ui';
@@ -22,8 +27,11 @@ import { Pipeline } from '@dxos/types';
 import { ghostHover, mx } from '@dxos/ui-theme';
 import { isNonNullable } from '@dxos/util';
 
-import { meta } from '../../meta';
+import { meta } from '#meta';
+
+import { type EdgeTriggersDispatcherStatusState, useEdgeTriggersDispatcherStatus } from '../../hooks';
 import { TriggerEditor, type TriggerEditorProps } from '../TriggerEditor';
+import { TriggerDispatcherSummary, TriggerEdgeMetadata } from './TriggerEdgeMetadata';
 
 const grid = 'grid grid-cols-[40px_1fr_32px_32px] min-h-[2.5rem]';
 
@@ -38,19 +46,25 @@ export type AutomationPanelProps = {
 export const AutomationPanel = ({ space, object, initialTrigger, onDone }: AutomationPanelProps) => {
   const { t } = useTranslation(meta.id);
   const client = useClient();
+  const processManagerRuntime = useProcessManagerRuntime();
+  const [properties] = useObject(space.properties);
+  const computeEnvironment = properties.computeEnvironment ?? 'local';
+  const edgeDispatcherStatus = useEdgeTriggersDispatcherStatus(space.id, computeEnvironment === 'edge');
   const functionsServiceClient = useMemo(() => FunctionsServiceClient.fromClient(client), [client]);
-  const functions = useQuery(space.db, Filter.type(Function.Function));
-  const triggers = useQuery(space.db, Filter.type(Trigger.Trigger));
+  const functions = useQuery(space.db, Filter.type(Operation.PersistentOperation));
+  const triggers = useQuery(
+    space.db,
+    Query.select(Filter.type(Trigger.Trigger)).debugLabel('plugin-automation.AutomationPanel'),
+  );
   const filteredTriggers = useMemo(() => {
     return object ? triggers.filter(triggerMatch(object)) : triggers;
   }, [object, triggers]);
   const tags = useQuery(space.db, Filter.type(Tag.Tag));
   const types = useTypeOptions({
-    space,
+    db: space.db,
     annotation: {
       location: ['database', 'runtime'],
       kind: ['user'],
-      registered: ['registered'],
     },
   });
 
@@ -75,8 +89,8 @@ export const AutomationPanel = ({ space, object, initialTrigger, onDone }: Autom
 
   const handleSave: TriggerEditorProps['onSave'] = (trigger) => {
     if (selected) {
-      Obj.change(selected, (mutable) => {
-        Object.assign(mutable, trigger);
+      Obj.update(selected, (selected) => {
+        Object.assign(selected, trigger);
       });
     } else {
       space.db.add(Trigger.make(trigger));
@@ -93,19 +107,44 @@ export const AutomationPanel = ({ space, object, initialTrigger, onDone }: Autom
   };
 
   const handleForceRunTrigger = async (trigger: Trigger.Trigger) => {
-    await functionsServiceClient.forceRunCronTrigger(space.id, trigger.id);
+    if (computeEnvironment === 'disabled') {
+      return;
+    }
+
+    if (computeEnvironment === 'local') {
+      try {
+        await processManagerRuntime.runPromise(
+          Effect.gen(function* () {
+            const dispatcher = yield* TriggerDispatcher;
+            yield* dispatcher.invokeTrigger({
+              trigger,
+              event: { tick: Date.now() } satisfies TriggerEvent.TimerEvent,
+            });
+          }).pipe(Effect.provide(ServiceResolver.provide({ space: space.id }, TriggerDispatcher))),
+        );
+      } catch (error) {
+        log.catch(error);
+      }
+      return;
+    }
+
+    try {
+      await functionsServiceClient.forceRunCronTrigger(Context.default(), space.id, trigger.id);
+    } catch (error) {
+      log.catch(error);
+    }
   };
 
   const handleResetCursor = async (trigger: Trigger.Trigger) => {
-    Obj.change(trigger, (t) => {
-      Obj.deleteKeys(t, KEY_QUEUE_CURSOR);
+    Obj.update(trigger, (trigger) => {
+      Obj.deleteKeys(trigger, KEY_FEED_CURSOR);
     });
     await space.db.flush({ indexes: true });
   };
 
   if (trigger) {
     return (
-      <Settings.Item title={t('trigger editor title')} description={t('trigger editor description')}>
+      <Settings.Item title={t('trigger-editor.title')} description={t('trigger-editor.description')}>
         <TriggerEditor
           db={space.db}
           trigger={trigger}
@@ -120,47 +159,64 @@ export const AutomationPanel = ({ space, object, initialTrigger, onDone }: Autom
   }
 
   return (
-    <Settings.Container>
-      {filteredTriggers.length > 0 && (
-        <List.Root<Trigger.Trigger>
-          items={filteredTriggers}
-          isItem={Schema.is(Trigger.Trigger)}
-          getId={(field) => field.id}
-        >
-          {({ items: filteredTriggers }) => (
-            <div role='list' className='flex flex-col w-full'>
-              {filteredTriggers?.map((trigger) => (
-                <TriggerListItem
-                  key={trigger.id}
-                  trigger={trigger}
-                  functions={functions}
-                  onSelect={handleSelect}
-                  onDelete={handleDelete}
-                  onResetCursor={handleResetCursor}
-                  onForceRun={handleForceRunTrigger}
-                />
-              ))}
-            </div>
-          )}
-        </List.Root>
-      )}
+    <Settings.Panel>
+      <Clipboard.Provider>
+        {computeEnvironment === 'edge' && (
+          <TriggerDispatcherSummary
+            status={edgeDispatcherStatus.status}
+            error={edgeDispatcherStatus.error}
+            loading={edgeDispatcherStatus.loading}
+            timerTriggers={filteredTriggers.filter((trigger) => trigger.spec?.kind === 'timer')}
+          />
+        )}
+
+        {filteredTriggers.length > 0 && (
+          <List.Root<Trigger.Trigger>
+            items={filteredTriggers}
+            isItem={Schema.is(Type.getSchema(Trigger.Trigger))}
+            getId={(field) => field.id}
+          >
+            {({ items: filteredTriggers }) => (
+              <div role='list' className='flex flex-col w-full'>
+                {filteredTriggers?.map((trigger) => (
+                  <TriggerListItem
+                    key={trigger.id}
+                    trigger={trigger}
+                    functions={functions}
+                    computeEnvironment={computeEnvironment}
+                    edgeDispatcherStatus={edgeDispatcherStatus}
+                    onSelect={handleSelect}
+                    onDelete={handleDelete}
+                    onResetCursor={handleResetCursor}
+                    onForceRun={handleForceRunTrigger}
+                  />
+                ))}
+              </div>
+            )}
+          </List.Root>
+        )}
 
-      {filteredTriggers.length > 0 && <Separator classNames='my-4' />}
-      <IconButton icon='ph--plus--regular' label={t('new trigger label')} onClick={handleAdd} />
-    </Settings.Container>
+        {filteredTriggers.length > 0 && <Separator classNames='my-4' />}
+        <IconButton icon='ph--plus--regular' label={t('new-trigger.label')} onClick={handleAdd} />
+      </Clipboard.Provider>
+    </Settings.Panel>
   );
 };
 
 const TriggerListItem = ({
   trigger,
   functions,
+  computeEnvironment,
+  edgeDispatcherStatus,
   onSelect,
   onDelete,
   onResetCursor,
   onForceRun,
 }: {
   trigger: Trigger.Trigger;
-  functions: Function.Function[];
+  functions: Operation.PersistentOperation[];
+  computeEnvironment: ComputeEnvironment;
+  edgeDispatcherStatus?: EdgeTriggersDispatcherStatusState;
   onSelect?: (trigger: Trigger.Trigger) => void;
   onDelete?: (trigger: Trigger.Trigger) => void;
   onResetCursor?: (trigger: Trigger.Trigger) => void;
@@ -169,7 +225,7 @@ const TriggerListItem = ({
   const client = useClient();
   const copyAction = getCopyAction(client, trigger);
   const { t } = useTranslation(meta.id);
-  const cursor = Obj.getKeys(trigger, KEY_QUEUE_CURSOR).at(0)?.id;
+  const cursor = Obj.getKeys(trigger, KEY_FEED_CURSOR).at(0)?.id;
   const [snapshot, updateTrigger] = useObject(trigger);
 
   const enabled = snapshot.enabled ?? false;
@@ -198,14 +254,14 @@ const TriggerListItem = ({
   const actionProps = useMemo<IconButtonProps | undefined>(() => {
     if (trigger.spec?.kind === 'timer' && onForceRun) {
       return {
-        disabled: !enabled || trigger.spec?.kind !== 'timer',
+        disabled: !enabled || computeEnvironment === 'disabled',
         icon: 'ph--play--regular',
         label: 'Force run',
         onClick: handleForceRun,
       };
     }
 
-    if (trigger.spec?.kind === 'queue' && onResetCursor) {
+    if (trigger.spec?.kind === 'feed' && onResetCursor) {
       return {
         disabled: !cursor,
         icon: 'ph--arrow-clockwise--regular',
@@ -213,7 +269,7 @@ const TriggerListItem = ({
         onClick: handleResetCursor,
       };
     }
-  }, [enabled, trigger.spec?.kind, handleForceRun]);
+  }, [computeEnvironment, enabled, trigger.spec?.kind, handleForceRun, onResetCursor]);
 
   return (
     <List.Item<Obj.Snapshot<Trigger.Trigger>>
@@ -225,18 +281,24 @@ const TriggerListItem = ({
         <Input.Switch checked={enabled} onCheckedChange={onEnabledChange} />
       </Input.Root>
 
-      <div className={'flex'}>
-        <List.ItemTitle classNames='px-1 cursor-pointer w-0 shrink truncate' onClick={handleSelect}>
-          {getFunctionName(functions, trigger) ?? '∅'}
-          {cursor && <div className='text-xs text-description truncate ml-4'>Position: {cursor}</div>}
-        </List.ItemTitle>
+      <div className='flex flex-col min-w-0'>
+        <div className='flex'>
+          <List.ItemTitle classNames='px-1 cursor-pointer w-0 shrink truncate' onClick={handleSelect}>
+            {getFunctionName(functions, trigger) ?? '∅'}
+          </List.ItemTitle>
+
+          {copyAction && (
+            <Clipboard.IconButton label={t(copyAction.translationKey)} value={copyAction.contentProvider()} />
+          )}
+        </div>
 
-        {copyAction && (
-          <Clipboard.IconButton label={t(copyAction.translationKey)} value={copyAction.contentProvider()} />
+        {cursor && <div className='text-xs text-description truncate ml-4'>Position: {cursor}</div>}
+        {computeEnvironment === 'edge' && edgeDispatcherStatus && (
+          <TriggerEdgeMetadata trigger={trigger} edgeStatus={edgeDispatcherStatus} />
         )}
       </div>
 
-      {actionProps ? <List.ItemButton {...actionProps} autoHide={false} /> : <div />}
+      {actionProps ? <List.ItemIconButton {...actionProps} autoHide={false} /> : <div />}
 
       {onDelete && <List.ItemDeleteButton onClick={handleDelete} />}
     </List.Item>
@@ -269,17 +331,17 @@ const getWebhookUrl = (client: Client, trigger: Trigger.Trigger) => {
   return new URL(`/webhook/${spaceId}:${trigger.id}`, edgeUrl).toString();
 };
 
-const getFunctionName = (functions: Function.Function[], trigger: Trigger.Trigger) => {
+const getFunctionName = (functions: Operation.PersistentOperation[], trigger: Trigger.Trigger) => {
   // TODO(wittjosiah): Truncation should be done in the UI.
   //   Warning that the List component is currently a can of worms.
-  const shortId = trigger.function && `${trigger.function.dxn.toString().slice(0, 16)}…`;
+  const shortId = trigger.function && `${trigger.function.uri.slice(0, 16)}…`;
   const functionObject = functions.find((fn) => fn === trigger.function?.target);
   return functionObject?.name ?? shortId;
 };
 
 const scriptMatch = (script: Script.Script) => (trigger: Trigger.Trigger) => {
   const fn = trigger.function?.target;
-  if (!Obj.instanceOf(Function.Function, fn)) {
+  if (!Obj.instanceOf(Operation.PersistentOperation, fn)) {
     return false;
   }