@dxos/plugin-automation 0.8.4-main.fd6878d → 0.8.4-staging.60fe92afc8

package/src/capabilities/trigger-runtime-controller.ts

@@ -0,0 +1,126 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+import * as Fiber from 'effect/Fiber';
+
+import { Capabilities, Capability } from '@dxos/app-framework';
+import { type ComputeEnvironment } from '@dxos/client-protocol';
+import { ServiceResolver } from '@dxos/compute';
+import { Obj } from '@dxos/echo';
+import { TriggerDispatcher } from '@dxos/functions-runtime';
+import { type SpaceId } from '@dxos/keys';
+import { log } from '@dxos/log';
+import { ClientCapabilities } from '@dxos/plugin-client';
+import { type Space } from '@dxos/react-client/echo';
+
+//
+// Capability Module
+//
+// Watches `space.properties.computeEnvironment` for every space and toggles
+// the per-space {@link TriggerDispatcher} accordingly:
+//
+//   - `local`              → `dispatcher.start()`
+//   - `edge` / `disabled`  → `dispatcher.stop()`
+//
+// Replaces the in-line watcher that used to live inside the removed
+// `compute-runtime.ts` per-space layer. The dispatcher itself is now
+// contributed unconditionally via `TriggerDispatcherSpec` in `layer-specs.ts`,
+// so this capability is only responsible for driving its lifecycle.
+//
+
+/** Trigger execution location the dispatcher should run locally. */
+const LOCAL_ENVIRONMENT: ComputeEnvironment = 'local';
+
+export default Capability.makeModule(
+  Effect.fnUntraced(function* () {
+    const client = yield* Capability.get(ClientCapabilities.Client);
+    const runtime = yield* Capability.get(Capabilities.ProcessManagerRuntime);
+
+    /** Per-space property-subscription unsubscribe, last-seen environment, and in-flight transition fiber. */
+    type Tracker = {
+      unsubscribe: () => void;
+      lastEnvironment?: ComputeEnvironment;
+      inFlight?: Fiber.RuntimeFiber<unknown, unknown>;
+    };
+    const trackers = new Map<SpaceId, Tracker>();
+
+    /**
+     * Resolve the per-space `TriggerDispatcher` from the process-manager
+     * runtime and invoke `start()` / `stop()` according to the requested
+     * environment. Returns a fiber so the caller can cancel a pending
+     * transition when a new one supersedes it.
+     */
+    const transition = (spaceId: SpaceId, environment: ComputeEnvironment) =>
+      runtime.runFork(
+        Effect.gen(function* () {
+          const dispatcher = yield* TriggerDispatcher;
+          yield* environment === LOCAL_ENVIRONMENT ? dispatcher.start() : dispatcher.stop();
+        }).pipe(
+          Effect.provide(ServiceResolver.provide({ space: spaceId }, TriggerDispatcher)),
+          Effect.tapErrorCause((cause) =>
+            Effect.sync(() => log.warn('trigger dispatcher transition failed', { spaceId, environment, cause })),
+          ),
+        ),
+      );
+
+    const apply = (tracker: Tracker, spaceId: SpaceId, environment: ComputeEnvironment): void => {
+      if (tracker.lastEnvironment === environment) {
+        return;
+      }
+      tracker.lastEnvironment = environment;
+      if (tracker.inFlight) {
+        runtime.runFork(Fiber.interrupt(tracker.inFlight));
+      }
+      tracker.inFlight = transition(spaceId, environment);
+    };
+
+    const install = (space: Space): void => {
+      if (trackers.has(space.id)) {
+        return;
+      }
+      // Reserve the slot synchronously so concurrent `client.spaces.subscribe`
+      // notifications (e.g. spaces array churn while we await readiness) don't
+      // wire a second subscriber for the same space.
+      const tracker: Tracker = { unsubscribe: () => {} };
+      trackers.set(space.id, tracker);
+
+      void space
+        .waitUntilReady()
+        .then(() => {
+          // The capability could have been torn down between `set` and the
+          // promise resolving; bail out without subscribing in that case.
+          if (trackers.get(space.id) !== tracker) {
+            return;
+          }
+          const readEnvironment = (): ComputeEnvironment => space.properties.computeEnvironment ?? LOCAL_ENVIRONMENT;
+          tracker.unsubscribe = Obj.subscribe(space.properties, () => apply(tracker, space.id, readEnvironment()));
+          apply(tracker, space.id, readEnvironment());
+        })
+        .catch((err) => log.catch(err));
+    };
+
+    const installAll = (spaces: readonly Space[]): void => {
+      for (const space of spaces) {
+        install(space);
+      }
+    };
+
+    const spacesSubscription = client.spaces.subscribe(installAll);
+    installAll(client.spaces.get());
+
+    return Capability.contributes(Capabilities.Null, null, () =>
+      Effect.sync(() => {
+        spacesSubscription.unsubscribe();
+        for (const tracker of trackers.values()) {
+          tracker.unsubscribe();
+          if (tracker.inFlight) {
+            runtime.runFork(Fiber.interrupt(tracker.inFlight));
+          }
+        }
+        trackers.clear();
+      }),
+    );
+  }),
+);

package/src/commands/index.ts

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

package/src/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/commands/trigger/create/queue.ts

@@ -0,0 +1,87 @@
+//
+// 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 { Operation, Trigger } from '@dxos/compute';
+import { Database, Feed as FeedNs, Filter, JsonSchema, Ref } from '@dxos/echo';
+import { EID } from '@dxos/keys';
+
+import { Enabled, Feed, Input } from '../options';
+import { printTrigger, promptForSchemaInput, selectFunction, selectFeed } from '../util';
+
+export const queue = Command.make(
+  'feed',
+  {
+    spaceId: Common.spaceId.pipe(Options.optional),
+    enabled: Enabled,
+    functionId: Common.functionId.pipe(Options.optional),
+    feed: Feed.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.query(Filter.type(Operation.PersistentOperation)).run;
+      const fn = functions.find((fn) => fn.id === functionId);
+      if (!fn) {
+        return yield* Effect.fail(new Error(`Function not found: ${functionId}`));
+      }
+
+      const feed = yield* Option.match(options.feed, {
+        onNone: () => selectFeed(),
+        onSome: (uri) => Database.resolve(EID.parse(uri), FeedNs.Feed),
+      });
+
+      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: Trigger.specFeed(feed),
+        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 feed trigger.'),
+  Command.provide(({ spaceId }) => spaceLayer(spaceId, true)),
+  Command.provideEffectDiscard(() => withTypes(Operation.PersistentOperation, Trigger.Trigger)),
+);

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

@@ -0,0 +1,126 @@
+//
+// 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 { Operation, Trigger } from '@dxos/compute';
+import { Database, Filter, JsonSchema, Query, Ref } from '@dxos/echo';
+import { DXN } from '@dxos/keys';
+
+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.query(Filter.type(Operation.PersistentOperation)).run;
+      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 subscriptionQuery = Query.select(Filter.type(DXN.make(typename)));
+
+      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: Trigger.specSubscription(
+          subscriptionQuery,
+          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/commands/trigger/create/timer.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 { Operation, Trigger } from '@dxos/compute';
+import { Database, Filter, JsonSchema, Ref } from '@dxos/echo';
+
+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.query(Filter.type(Operation.PersistentOperation)).run;
+      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: Trigger.specTimer(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/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/commands/trigger/list.ts

@@ -0,0 +1,69 @@
+//
+// 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 { Trigger } from '@dxos/compute';
+import { Context } from '@dxos/context';
+import { Database, Filter, Query } from '@dxos/echo';
+
+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.query(Query.select(Filter.type(Trigger.Trigger)).debugLabel('cli.trigger.list'))
+      .run;
+
+    // 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/commands/trigger/options.ts

@@ -0,0 +1,47 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Options from '@effect/cli/Options';
+
+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.'),
+);
+
+//
+// Feed
+//
+
+export const Feed = Options.text('feed').pipe(
+  Options.withDescription('The EID of the feed for the feed trigger (echo://<spaceId>/<objectId>).'),
+);

package/src/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 { Trigger } from '@dxos/compute';
+import { Database, Ref } from '@dxos/echo';
+import { EID } from '@dxos/keys';
+
+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 = EID.make({ entityId: triggerId });
+      const trigger = yield* Database.resolve(Ref.fromURI(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/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]),
+);