@dxos/plugin-automation 0.8.4-main.72ec0f3 → 0.8.4-main.74a063c4e0

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]),
+);

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

@@ -0,0 +1,195 @@
+//
+// 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 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 { DXN, Database, Filter, JsonSchema, Obj, Ref } from '@dxos/echo';
+import { Trigger } from '@dxos/functions';
+import { Operation } from '@dxos/operation';
+
+import { Enabled, Input, Queue, TriggerId } from '../options';
+import { printTrigger, promptForSchemaInput, selectFunction, selectQueue, selectTrigger } from '../util';
+
+export const queue = Command.make(
+  'queue',
+  {
+    spaceId: Common.spaceId.pipe(Options.optional),
+    id: TriggerId.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 triggerId = yield* Option.match(options.id, {
+        onNone: () => selectTrigger('queue'),
+        onSome: (id) => Effect.succeed(id),
+      });
+      const dxn = DXN.fromLocalObjectId(triggerId);
+      const trigger = yield* Database.resolve(dxn, Trigger.Trigger);
+      if (trigger.spec?.kind !== 'queue') {
+        return yield* Effect.fail(new Error(`Invalid trigger type: ${trigger.spec?.kind}`));
+      }
+
+      const currentFn = yield* updateFunction(trigger, options.functionId);
+      yield* updateQueue(trigger, options.queue);
+      yield* updateInput(trigger, currentFn, options.input);
+      yield* updateEnabled(trigger, options.id, options.enabled);
+
+      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('Update a queue trigger.'),
+  Command.provide(({ spaceId }) => spaceLayer(spaceId, true)),
+  Command.provideEffectDiscard(() => withTypes(Operation.PersistentOperation, Trigger.Trigger)),
+);
+
+/**
+ * Handles updating the function for a trigger.
+ * Prompts for confirmation if functionId is not provided, then updates the function if confirmed.
+ * @returns The current function (either original or newly assigned)
+ */
+const updateFunction = Effect.fn(function* (trigger: Trigger.Trigger, functionIdOption: Option.Option<string>) {
+  let currentFn: Operation.PersistentOperation | undefined = trigger.function
+    ? yield* Database.load(trigger.function) as any
+    : undefined;
+  if (currentFn && !Obj.instanceOf(Operation.PersistentOperation, currentFn)) {
+    currentFn = undefined;
+  }
+  const currentFunctionName = currentFn ? (currentFn.name ?? currentFn.id) : undefined;
+  const shouldChangeFunction = yield* Option.match(functionIdOption, {
+    onNone: () =>
+      Prompt.confirm({
+        message: `Change the function${currentFunctionName ? ` (current: ${currentFunctionName})` : ''}?`,
+        initial: false,
+      }).pipe(Prompt.run),
+    onSome: () => Effect.succeed(true),
+  });
+  if (shouldChangeFunction) {
+    const functionId = yield* Option.match(functionIdOption, {
+      onNone: () => selectFunction(),
+      onSome: (id) => Effect.succeed(id),
+    });
+    const functions = yield* Database.runQuery(Filter.type(Operation.PersistentOperation));
+    const foundFn = functions.find((fn) => fn.id === functionId);
+    if (!foundFn || !Obj.instanceOf(Operation.PersistentOperation, foundFn)) {
+      return yield* Effect.fail(new Error(`Function not found: ${functionId}`));
+    }
+    Obj.change(trigger, (mutableTrigger) => {
+      mutableTrigger.function = Ref.make(foundFn);
+    });
+    currentFn = foundFn;
+  }
+
+  if (!currentFn) {
+    const functionId = trigger.function?.dxn.asEchoDXN()?.echoId ?? 'unknown';
+    return yield* Effect.fail(new Error(`Invalid reference for ${functionId}`));
+  }
+
+  return currentFn;
+});
+
+/**
+ * Handles updating the queue DXN for a queue trigger.
+ * Prompts for confirmation if queue is not provided, then updates the queue if confirmed.
+ */
+const updateQueue = Effect.fn(function* (trigger: Trigger.Trigger, queueOption: Option.Option<DXN>) {
+  const currentQueue = trigger.spec?.kind === 'queue' ? trigger.spec.queue : undefined;
+  const currentQueueStr = currentQueue
+    ? typeof currentQueue === 'string'
+      ? currentQueue
+      : String(currentQueue)
+    : undefined;
+  const shouldChangeQueue = yield* Option.match(queueOption, {
+    onNone: () =>
+      Prompt.confirm({
+        message: `Change the queue${currentQueueStr ? ` (current: ${currentQueueStr})` : ''}?`,
+        initial: false,
+      }).pipe(Prompt.run),
+    onSome: () => Effect.succeed(true),
+  });
+  if (shouldChangeQueue) {
+    const queueDxn = yield* Option.match(queueOption, {
+      onNone: () => selectQueue(),
+      onSome: (dxn) => Effect.succeed(dxn.toString()),
+    });
+    Obj.change(trigger, (mutableTrigger) => {
+      if (mutableTrigger.spec?.kind === 'queue') {
+        mutableTrigger.spec.queue = queueDxn;
+      }
+    });
+  }
+});
+
+/**
+ * Handles updating the input for a trigger.
+ * Prompts for confirmation if input is not provided, then updates the input if confirmed.
+ */
+const updateInput = Effect.fn(function* (
+  trigger: Trigger.Trigger,
+  fn: Operation.PersistentOperation,
+  inputOption: Option.Option<Record<string, any>>,
+) {
+  const currentInput = trigger.input as Record<string, any> | undefined;
+  const currentInputStr = currentInput ? JSON.stringify(currentInput) : 'none';
+  const shouldChangeInput = yield* Option.match(inputOption, {
+    onNone: () =>
+      Effect.gen(function* () {
+        yield* Console.log(`Current input: ${currentInputStr}`);
+        return yield* Prompt.confirm({
+          message: 'Change input?',
+          initial: false,
+        }).pipe(Prompt.run);
+      }),
+    onSome: () => Effect.succeed(true),
+  });
+  if (shouldChangeInput) {
+    const inputObj = yield* Option.match(inputOption, {
+      onNone: () =>
+        promptForSchemaInput(fn.inputSchema ? JsonSchema.toEffectSchema(fn.inputSchema) : undefined, currentInput),
+      onSome: (value) => Effect.succeed(value as Record<string, any>),
+    });
+    Obj.change(trigger, (mutableTrigger) => {
+      mutableTrigger.input = inputObj;
+    });
+  }
+});
+
+/**
+ * Handles updating the enabled status for a trigger.
+ * Prompts for enabled if id is not provided.
+ */
+const updateEnabled = Effect.fn(function* (
+  trigger: Trigger.Trigger,
+  idOption: Option.Option<string>,
+  enabled: boolean,
+) {
+  const enabledValue = yield* Option.match(idOption, {
+    onNone: () =>
+      Prompt.confirm({
+        message: 'Enable the trigger?',
+        initial: trigger.enabled,
+      }).pipe(Prompt.run),
+    onSome: () => Effect.succeed(enabled),
+  });
+  Obj.change(trigger, (mutableTrigger) => {
+    mutableTrigger.enabled = enabledValue;
+  });
+});