@dxos/plugin-automation 0.8.4-main.b97322e → 0.8.4-main.bcb3aa67d6

package/src/capabilities/react-surface.tsx

@@ -2,55 +2,56 @@
 // Copyright 2025 DXOS.org
 //
 
+import * as Effect from 'effect/Effect';
 import React from 'react';
 
-import { Capabilities, contributes, createSurface, useLayout } from '@dxos/app-framework';
+import { Capabilities, Capability } from '@dxos/app-framework';
+import { Surface } from '@dxos/app-framework/ui';
 import { Obj } from '@dxos/echo';
-import { ScriptType } from '@dxos/functions';
-import { getSpace, parseId, useSpace } from '@dxos/react-client/echo';
+import { useActiveSpace } from '@dxos/app-toolkit/ui';
+import { getSpace } from '@dxos/react-client/echo';
 
-import { AutomationContainer, FunctionsContainer } from '../components';
-import { meta } from '../meta';
+import { AutomationSettings, FunctionsContainer } from '#containers';
+import { meta } from '#meta';
 
-export default () =>
-  contributes(Capabilities.ReactSurface, [
-    createSurface({
-      id: `${meta.id}/space-settings-automation`,
-      role: 'article',
-      filter: (data): data is { subject: string } => data.subject === `${meta.id}/space-settings-automation`,
-      component: () => {
-        const layout = useLayout();
-        const { spaceId } = parseId(layout.workspace);
-        const space = useSpace(spaceId);
-        if (!space || !spaceId) {
-          return null;
-        }
+export default Capability.makeModule(() =>
+  Effect.succeed(
+    Capability.contributes(Capabilities.ReactSurface, [
+      Surface.create({
+        id: `${meta.id}.space-settings-functions`,
+        role: 'article',
+        filter: (data): data is { subject: string } => data.subject === `${meta.id}.space-settings-functions`,
+        component: () => {
+          const space = useActiveSpace();
+          if (!space) {
+            return null;
+          }
 
-        return <AutomationContainer space={space} />;
-      },
-    }),
-    createSurface({
-      id: `${meta.id}/space-settings-functions`,
-      role: 'article',
-      filter: (data): data is { subject: string } => data.subject === `${meta.id}/space-settings-functions`,
-      component: () => {
-        const layout = useLayout();
-        const { spaceId } = parseId(layout.workspace);
-        const space = useSpace(spaceId);
-        if (!space || !spaceId) {
-          return null;
-        }
+          return <FunctionsContainer space={space} />;
+        },
+      }),
+      Surface.create({
+        id: `${meta.id}.space-settings-automation`,
+        role: 'article',
+        filter: (data): data is { subject: string } => data.subject === `${meta.id}.space-settings-automation`,
+        component: () => {
+          const space = useActiveSpace();
+          if (!space) {
+            return null;
+          }
 
-        return <FunctionsContainer space={space} />;
-      },
-    }),
-    createSurface({
-      id: `${meta.id}/companion/automation`,
-      role: 'article',
-      filter: (data): data is { companionTo: ScriptType; subject: 'automation' } =>
-        Obj.instanceOf(ScriptType, data.companionTo) && data.subject === 'automation',
-      component: ({ data, role }) => {
-        return <AutomationContainer space={getSpace(data.companionTo)!} object={data.companionTo} />;
-      },
-    }),
-  ]);
+          return <AutomationSettings space={space} />;
+        },
+      }),
+      Surface.create({
+        id: `${meta.id}.companion.automation`,
+        role: 'article',
+        filter: (data): data is { companionTo: Obj.Unknown; subject: 'automation' } =>
+          Obj.isObject(data.companionTo) && data.subject === 'automation',
+        component: ({ data }) => {
+          return <AutomationSettings space={getSpace(data.companionTo)!} object={data.companionTo} />;
+        },
+      }),
+    ]),
+  ),
+);

package/src/cli/commands/index.ts

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

package/src/cli/commands/trigger/create/index.ts

@@ -0,0 +1,14 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Command from '@effect/cli/Command';
+
+import { queue } from './queue';
+import { subscription } from './subscription';
+import { timer } from './timer';
+
+export const create = Command.make('create').pipe(
+  Command.withDescription('Create a trigger.'),
+  Command.withSubcommands([subscription, timer, queue]),
+);

package/src/cli/commands/trigger/create/queue.ts

@@ -0,0 +1,90 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Command from '@effect/cli/Command';
+import * as Options from '@effect/cli/Options';
+import * as Prompt from '@effect/cli/Prompt';
+import * as Console from 'effect/Console';
+import * as Effect from 'effect/Effect';
+import * as HashMap from 'effect/HashMap';
+import * as Option from 'effect/Option';
+
+import { CommandConfig } from '@dxos/cli-util';
+import { flushAndSync, print, spaceLayer, withTypes } from '@dxos/cli-util';
+import { Common } from '@dxos/cli-util';
+import { Database, Filter, JsonSchema, Ref } from '@dxos/echo';
+import { Trigger } from '@dxos/functions';
+import { Operation } from '@dxos/operation';
+
+import { Enabled, Input, Queue } from '../options';
+import { printTrigger, promptForSchemaInput, selectFunction, selectQueue } from '../util';
+
+export const queue = Command.make(
+  'queue',
+  {
+    spaceId: Common.spaceId.pipe(Options.optional),
+    enabled: Enabled,
+    functionId: Common.functionId.pipe(Options.optional),
+    queue: Queue.pipe(Options.optional),
+    input: Input.pipe(Options.optional),
+  },
+  (options) =>
+    Effect.gen(function* () {
+      const { json } = yield* CommandConfig;
+
+      const functionId = yield* Option.match(options.functionId, {
+        onNone: () => selectFunction(),
+        onSome: (id) => Effect.succeed(id),
+      });
+      const functions = yield* Database.runQuery(Filter.type(Operation.PersistentOperation));
+      const fn = functions.find((fn) => fn.id === functionId);
+      if (!fn) {
+        return yield* Effect.fail(new Error(`Function not found: ${functionId}`));
+      }
+
+      const queueDxn = yield* Option.match(options.queue, {
+        onNone: () => selectQueue(),
+        onSome: (dxn) => Effect.succeed(dxn.toString()),
+      });
+
+      const input = yield* Option.match(options.input, {
+        onNone: () => promptForSchemaInput(fn.inputSchema ? JsonSchema.toEffectSchema(fn.inputSchema) : undefined),
+        onSome: (value) => Effect.succeed(Object.fromEntries(HashMap.toEntries(value))),
+      });
+
+      // Always prompt for enabled if functionId is not provided.
+      const enabled = yield* Option.match(options.functionId, {
+        onNone: () =>
+          Prompt.confirm({
+            message: 'Enable the trigger?',
+            initial: true,
+          }).pipe(Prompt.run),
+        onSome: () => Effect.succeed(options.enabled),
+      });
+
+      const trigger = Trigger.make({
+        function: Ref.make(fn),
+        enabled,
+        spec: {
+          kind: 'queue',
+          queue: queueDxn,
+        },
+        input,
+      });
+
+      yield* Database.add(trigger);
+
+      if (json) {
+        yield* Console.log(JSON.stringify(trigger, null, 2));
+      } else {
+        yield* Console.log(print(yield* printTrigger(trigger)));
+      }
+
+      yield* flushAndSync({ indexes: true });
+    }),
+).pipe(
+  Command.withDescription('Create a queue trigger.'),
+  Command.provide(({ spaceId }) => spaceLayer(spaceId, true)),
+  Command.provideEffectDiscard(() => withTypes(Operation.PersistentOperation, Trigger.Trigger)),
+);

package/src/cli/commands/trigger/create/subscription.ts

@@ -0,0 +1,129 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Command from '@effect/cli/Command';
+import * as Options from '@effect/cli/Options';
+import * as Prompt from '@effect/cli/Prompt';
+import * as Console from 'effect/Console';
+import * as Effect from 'effect/Effect';
+import * as HashMap from 'effect/HashMap';
+import * as Option from 'effect/Option';
+
+import { CommandConfig } from '@dxos/cli-util';
+import { flushAndSync, print, spaceLayer, withTypes } from '@dxos/cli-util';
+import { Common } from '@dxos/cli-util';
+import { Database, Filter, JsonSchema, Query, Ref } from '@dxos/echo';
+import { Trigger } from '@dxos/functions';
+import { Operation } from '@dxos/operation';
+
+import { Deep, Delay, Enabled, Input, Typename } from '../options';
+import { printTrigger, promptForSchemaInput, selectFunction } from '../util';
+
+export const subscription = Command.make(
+  'subscription',
+  {
+    spaceId: Common.spaceId.pipe(Options.optional),
+    enabled: Enabled,
+    functionId: Common.functionId.pipe(Options.optional),
+    typename: Typename.pipe(Options.optional),
+    deep: Deep.pipe(Options.optional),
+    delay: Delay.pipe(Options.optional),
+    input: Input.pipe(Options.optional),
+  },
+  (options) =>
+    Effect.gen(function* () {
+      const { json } = yield* CommandConfig;
+
+      const functionId = yield* Option.match(options.functionId, {
+        onNone: () => selectFunction(),
+        onSome: (id) => Effect.succeed(id),
+      });
+      const functions = yield* Database.runQuery(Filter.type(Operation.PersistentOperation));
+      const fn = functions.find((fn) => fn.id === functionId);
+      if (!fn) {
+        return yield* Effect.fail(new Error(`Function not found: ${functionId}`));
+      }
+
+      const typename = yield* Option.match(options.typename, {
+        onNone: () =>
+          Prompt.text({
+            message: 'Enter type name:',
+          }).pipe(Prompt.run),
+        onSome: (value) => Effect.succeed(value),
+      });
+      const queryAst = Query.select(Filter.type(typename)).ast;
+
+      const deepOption = yield* Option.match(options.deep, {
+        onNone: () =>
+          Prompt.confirm({
+            message: 'Watch changes to nested properties (deep)?',
+            initial: false,
+          }).pipe(
+            Prompt.run,
+            Effect.map((value) => (value ? Option.some(value) : Option.none())),
+          ),
+        onSome: () => Effect.succeed(Option.some(true)),
+      });
+
+      const delayOption = yield* Option.match(options.delay, {
+        onNone: () =>
+          Effect.gen(function* () {
+            const delayStr = yield* Prompt.text({
+              message: 'Debounce delay in milliseconds (optional, press Enter to skip):',
+            }).pipe(Prompt.run);
+            return delayStr === '' ? Option.none<number>() : Option.some(parseInt(delayStr, 10));
+          }),
+        onSome: (value) => Effect.succeed(Option.some(value)),
+      });
+
+      const subscriptionOptions: { deep?: boolean; delay?: number } = {};
+      if (Option.isSome(deepOption)) {
+        subscriptionOptions.deep = deepOption.value;
+      }
+      if (Option.isSome(delayOption)) {
+        subscriptionOptions.delay = delayOption.value;
+      }
+
+      const input = yield* Option.match(options.input, {
+        onNone: () => promptForSchemaInput(fn.inputSchema ? JsonSchema.toEffectSchema(fn.inputSchema) : undefined),
+        onSome: (value) => Effect.succeed(Object.fromEntries(HashMap.toEntries(value))),
+      });
+
+      // Always prompt for enabled if functionId is not provided.
+      const enabled = yield* Option.match(options.functionId, {
+        onNone: () =>
+          Prompt.confirm({
+            message: 'Enable the trigger?',
+            initial: true,
+          }).pipe(Prompt.run),
+        onSome: () => Effect.succeed(options.enabled),
+      });
+
+      const trigger = Trigger.make({
+        function: Ref.make(fn),
+        enabled,
+        spec: {
+          kind: 'subscription',
+          query: {
+            ast: queryAst,
+          },
+          options: Object.keys(subscriptionOptions).length > 0 ? subscriptionOptions : undefined,
+        },
+        input,
+      });
+      yield* Database.add(trigger);
+
+      if (json) {
+        yield* Console.log(JSON.stringify(trigger, null, 2));
+      } else {
+        yield* Console.log(print(yield* printTrigger(trigger)));
+      }
+
+      yield* flushAndSync({ indexes: true });
+    }),
+).pipe(
+  Command.withDescription('Create a subscription trigger.'),
+  Command.provide(({ spaceId }) => spaceLayer(spaceId, true)),
+  Command.provideEffectDiscard(() => withTypes(Operation.PersistentOperation, Trigger.Trigger)),
+);

package/src/cli/commands/trigger/create/timer.ts

@@ -0,0 +1,94 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Command from '@effect/cli/Command';
+import * as Options from '@effect/cli/Options';
+import * as Prompt from '@effect/cli/Prompt';
+import * as Console from 'effect/Console';
+import * as Effect from 'effect/Effect';
+import * as HashMap from 'effect/HashMap';
+import * as Option from 'effect/Option';
+
+import { CommandConfig } from '@dxos/cli-util';
+import { flushAndSync, print, spaceLayer, withTypes } from '@dxos/cli-util';
+import { Common } from '@dxos/cli-util';
+import { Database, Filter, JsonSchema, Ref } from '@dxos/echo';
+import { Trigger } from '@dxos/functions';
+import { Operation } from '@dxos/operation';
+
+import { Cron, Enabled, Input } from '../options';
+import { printTrigger, promptForSchemaInput, selectFunction } from '../util';
+
+// trigger create timer --cron "0 0 * * *" --functionId <functionId>
+export const timer = Command.make(
+  'timer',
+  {
+    spaceId: Common.spaceId.pipe(Options.optional),
+    enabled: Enabled,
+    functionId: Common.functionId.pipe(Options.optional),
+    cron: Cron.pipe(Options.optional),
+    input: Input.pipe(Options.optional),
+  },
+  (options) =>
+    Effect.gen(function* () {
+      const { json } = yield* CommandConfig;
+
+      const functionId = yield* Option.match(options.functionId, {
+        onNone: () => selectFunction(),
+        onSome: (id) => Effect.succeed(id),
+      });
+      const functions = yield* Database.runQuery(Filter.type(Operation.PersistentOperation));
+      const fn = functions.find((fn) => fn.id === functionId);
+      if (!fn) {
+        return yield* Effect.fail(new Error(`Function not found: ${functionId}`));
+      }
+
+      const cron = yield* Option.match(options.cron, {
+        onNone: () =>
+          Prompt.text({
+            message: 'Enter cron expression:',
+          }).pipe(Prompt.run),
+        onSome: (value) => Effect.succeed(value),
+      });
+
+      const input = yield* Option.match(options.input, {
+        onNone: () => promptForSchemaInput(fn.inputSchema ? JsonSchema.toEffectSchema(fn.inputSchema) : undefined),
+        onSome: (value) => Effect.succeed(Object.fromEntries(HashMap.toEntries(value))),
+      });
+
+      // Always prompt for enabled if functionId is not provided.
+      const enabled = yield* Option.match(options.functionId, {
+        onNone: () =>
+          Prompt.confirm({
+            message: 'Enable the trigger?',
+            initial: true,
+          }).pipe(Prompt.run),
+        onSome: () => Effect.succeed(options.enabled),
+      });
+
+      const trigger = Trigger.make({
+        function: Ref.make(fn),
+        enabled,
+        spec: {
+          kind: 'timer',
+          cron,
+        },
+        input,
+      });
+
+      yield* Database.add(trigger);
+
+      if (json) {
+        yield* Console.log(JSON.stringify(trigger, null, 2));
+      } else {
+        yield* Console.log(print(yield* printTrigger(trigger)));
+      }
+
+      yield* flushAndSync({ indexes: true });
+    }),
+).pipe(
+  Command.withDescription('Create a timer trigger.'),
+  Command.provide(({ spaceId }) => spaceLayer(spaceId, true)),
+  Command.provideEffectDiscard(() => withTypes(Operation.PersistentOperation, Trigger.Trigger)),
+);

package/src/cli/commands/trigger/index.ts

@@ -0,0 +1,16 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Command from '@effect/cli/Command';
+
+import { create } from './create';
+import { list } from './list';
+import { remove } from './remove';
+import { update } from './update';
+
+// TODO(wittjosiah): Rename to automation to align with Composer?
+export const trigger = Command.make('trigger').pipe(
+  Command.withDescription('Manage EDGE triggers.'),
+  Command.withSubcommands([create, list, remove, update]),
+);

package/src/cli/commands/trigger/list.ts

@@ -0,0 +1,68 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Command from '@effect/cli/Command';
+import * as Options from '@effect/cli/Options';
+import * as Console from 'effect/Console';
+import * as Effect from 'effect/Effect';
+
+import { CommandConfig, Common, printList, spaceIdWithDefault, spaceLayer } from '@dxos/cli-util';
+import { ClientService } from '@dxos/client';
+import { Context } from '@dxos/context';
+import { Database, Filter } from '@dxos/echo';
+import { Trigger } from '@dxos/functions';
+
+import { getTriggerRemoteStatus, printTrigger } from './util';
+
+export const list = Command.make(
+  'list',
+  {
+    spaceId: Common.spaceId.pipe(Options.optional),
+  },
+  Effect.fn(function* ({ spaceId: spaceIdOption }) {
+    const { json } = yield* CommandConfig;
+
+    // Fetch local triggers
+    const triggers = yield* Database.runQuery(Filter.type(Trigger.Trigger));
+
+    // Fetch remote cron triggers to check availability
+    const remoteCronIds = yield* Effect.gen(function* () {
+      const client = yield* ClientService;
+      const spaceId = yield* spaceIdWithDefault(spaceIdOption);
+      const result = yield* Effect.promise(() => client.edge.http.getCronTriggers(Context.default(), spaceId)).pipe(
+        Effect.catchAll(() => Effect.succeed({ cronIds: [] })),
+      );
+      return result.cronIds;
+    });
+
+    // Determine remote status for each trigger
+    const triggersWithStatus = triggers.map((trigger) => ({
+      trigger,
+      remoteStatus: getTriggerRemoteStatus(trigger, remoteCronIds),
+    }));
+
+    // Print triggers
+    if (json) {
+      yield* Console.log(
+        JSON.stringify(
+          triggersWithStatus.map(({ trigger, remoteStatus }) => ({ ...trigger, remoteStatus })),
+          null,
+          2,
+        ),
+      );
+    } else {
+      if (triggersWithStatus.length === 0) {
+        yield* Console.log('No triggers found.');
+      } else {
+        const items = yield* Effect.all(
+          triggersWithStatus.map(({ trigger, remoteStatus }) => printTrigger(trigger, remoteStatus)),
+        );
+        yield* Console.log(printList(items));
+      }
+    }
+  }),
+).pipe(
+  Command.withDescription('List triggers configured on EDGE.'),
+  Command.provide(({ spaceId }) => spaceLayer(spaceId, true)),
+);

package/src/cli/commands/trigger/options.ts

@@ -0,0 +1,59 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Options from '@effect/cli/Options';
+import * as Schema from 'effect/Schema';
+
+import { DXN } from '@dxos/keys';
+
+export const TriggerId = Options.text('id').pipe(Options.withDescription('The id of the trigger.'));
+
+export const Enabled = Options.boolean('enabled', { ifPresent: true }).pipe(
+  Options.withDescription('Whether the trigger is enabled.'),
+);
+
+export const Input = Options.keyValueMap('input').pipe(
+  Options.withDescription("Input data to pass to the function. Must match the function's input schema."),
+);
+
+//
+// Subscription
+//
+
+export const Typename = Options.text('typename').pipe(
+  Options.withDescription('The type name to query for the subscription trigger.'),
+);
+
+export const Deep = Options.boolean('deep', { ifPresent: true }).pipe(
+  Options.withDescription('Watch changes to nested properties (not just creation).'),
+);
+
+export const Delay = Options.integer('delay').pipe(
+  Options.withDescription('Debounce changes with a delay in milliseconds.'),
+);
+
+//
+// Timer
+//
+
+export const Cron = Options.text('cron').pipe(
+  Options.withDescription('The cron expression to use for the timer trigger.'),
+);
+
+//
+// Queue
+//
+
+// TODO(dmaretskyi): Extract
+const DXNSchema = Schema.String.pipe(
+  Schema.transform(Schema.instanceOf(DXN), {
+    decode: (value: string) => DXN.parse(value),
+    encode: (value: DXN) => value.toString(),
+  }),
+);
+
+export const Queue = Options.text('queue').pipe(
+  Options.withDescription('The DXN of the queue for the queue trigger.'),
+  Options.withSchema(DXNSchema),
+);

package/src/cli/commands/trigger/remove.ts

@@ -0,0 +1,45 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Command from '@effect/cli/Command';
+import * as Options from '@effect/cli/Options';
+import * as Console from 'effect/Console';
+import * as Effect from 'effect/Effect';
+import * as Option from 'effect/Option';
+
+import { CommandConfig, Common, print, spaceLayer, withTypes } from '@dxos/cli-util';
+import { DXN } from '@dxos/echo';
+import { Database } from '@dxos/echo';
+import { Trigger } from '@dxos/functions';
+
+import { TriggerId } from './options';
+import { printTriggerRemoved, selectTrigger } from './util';
+
+export const remove = Command.make(
+  'remove',
+  {
+    spaceId: Common.spaceId.pipe(Options.optional),
+    id: TriggerId.pipe(Options.optional),
+  },
+  (options) =>
+    Effect.gen(function* () {
+      const { json } = yield* CommandConfig;
+      const triggerId = yield* Option.match(options.id, {
+        onNone: () => selectTrigger(),
+        onSome: (id) => Effect.succeed(id),
+      });
+      const dxn = DXN.fromLocalObjectId(triggerId);
+      const trigger = yield* Database.resolve(dxn, Trigger.Trigger);
+      yield* Database.remove(trigger);
+      if (json) {
+        yield* Console.log(JSON.stringify({ id: trigger.id, removed: true }, null, 2));
+      } else {
+        yield* Console.log(print(printTriggerRemoved(trigger.id)));
+      }
+    }),
+).pipe(
+  Command.withDescription('Remove a trigger.'),
+  Command.provide(({ spaceId }) => spaceLayer(spaceId, true)),
+  Command.provideEffectDiscard(() => withTypes(Trigger.Trigger)),
+);

package/src/cli/commands/trigger/update/index.ts

@@ -0,0 +1,14 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Command from '@effect/cli/Command';
+
+import { queue } from './queue';
+import { subscription } from './subscription';
+import { timer } from './timer';
+
+export const update = Command.make('update').pipe(
+  Command.withDescription('Update a trigger.'),
+  Command.withSubcommands([subscription, timer, queue]),
+);