@dxos/plugin-automation 0.8.4-main.7ace549 → 0.8.4-main.8baae0fced

package/src/capabilities/layer-specs.ts

@@ -0,0 +1,231 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { Registry } from '@effect-atom/atom';
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
+
+import { OpaqueToolkit } from '@dxos/ai';
+import { Capabilities, Capability } from '@dxos/app-framework';
+import { AppCapabilities } from '@dxos/app-toolkit';
+import { ClientService } from '@dxos/client';
+import { Blueprint, LayerSpec, OperationHandlerSet, OperationRegistry } from '@dxos/compute';
+import { ProcessManager } from '@dxos/compute-runtime';
+import { Database, Feed } from '@dxos/echo';
+import { QueueService } from '@dxos/functions';
+import {
+  AgentService,
+  FeedTraceSink,
+  RemoteFunctionExecutionService,
+  TriggerDispatcher,
+  TriggerStateStore,
+} from '@dxos/functions-runtime';
+import { invariant } from '@dxos/invariant';
+import { ClientCapabilities } from '@dxos/plugin-client';
+
+//
+// Capability Module
+//
+// Contributes application- and space-affinity `Capabilities.LayerSpec` entries
+// that together replace the former monolithic `AutomationCapabilities.ComputeRuntime`.
+//
+// Specs are declared at module level; runtime state (the `Client`, contributed
+// capability lists, etc.) is resolved via Effect-level requirements rather
+// than captured from an outer scope.
+//
+
+/**
+ * Default application-affinity `RemoteFunctionExecutionService`. Space specs
+ * (see {@link RemoteFunctionExecutionOverrideSpec}) can override this with a
+ * space-scoped client.
+ */
+const RemoteFunctionExecutionSpec = LayerSpec.make(
+  {
+    affinity: 'application',
+    requires: [ClientService],
+    provides: [RemoteFunctionExecutionService],
+  },
+  () =>
+    Layer.unwrapEffect(
+      Effect.gen(function* () {
+        const client = yield* ClientService;
+        return RemoteFunctionExecutionService.fromClient(client);
+      }),
+    ),
+);
+
+/**
+ * Gathers contributed {@link Capabilities.OperationHandler} sets from the
+ * {@link Capability.Service} and exposes them through the
+ * {@link OperationHandlerSet.OperationHandlerProvider} tag so space-affinity
+ * specs (e.g. {@link OperationRegistrySpec}) can consume them through the
+ * normal LayerStack resolution path.
+ */
+const OperationHandlerProviderSpec = LayerSpec.make(
+  {
+    affinity: 'application',
+    requires: [Capability.Service],
+    provides: [OperationHandlerSet.OperationHandlerProvider],
+  },
+  () =>
+    Layer.unwrapEffect(
+      Effect.gen(function* () {
+        const operationHandlerSets = yield* Capability.getAll(Capabilities.OperationHandler);
+        const mergedOperationHandlers =
+          operationHandlerSets.length === 0
+            ? OperationHandlerSet.empty
+            : OperationHandlerSet.merge(...operationHandlerSets);
+        return OperationHandlerSet.provide(mergedOperationHandlers);
+      }),
+    ),
+);
+
+const BlueprintRegistrySpec = LayerSpec.make(
+  {
+    affinity: 'application',
+    requires: [Capability.Service],
+    provides: [Blueprint.RegistryService],
+  },
+  () =>
+    Layer.unwrapEffect(
+      Effect.gen(function* () {
+        const capabilities = yield* Capability.Service;
+        const blueprints = capabilities
+          .getAll(AppCapabilities.BlueprintDefinition)
+          .flatMap((blueprint) => blueprint.make());
+        return Layer.succeed(Blueprint.RegistryService, new Blueprint.Registry(blueprints));
+      }),
+    ),
+);
+
+const OpaqueToolkitSpec = LayerSpec.make(
+  {
+    affinity: 'application',
+    requires: [Capability.Service],
+    provides: [OpaqueToolkit.OpaqueToolkitProvider],
+  },
+  () =>
+    Layer.unwrapEffect(
+      Effect.gen(function* () {
+        const capabilities = yield* Capability.Service;
+        return Layer.succeed(OpaqueToolkit.OpaqueToolkitProvider, {
+          getToolkit: () => {
+            const toolkits = capabilities.getAll(AppCapabilities.Toolkit);
+            return OpaqueToolkit.merge(...toolkits);
+          },
+        });
+      }),
+    ),
+);
+
+const AgentServiceSpec = LayerSpec.make(
+  {
+    affinity: 'application',
+    requires: [ProcessManager.ProcessManagerService],
+    provides: [AgentService.AgentService],
+  },
+  () => AgentService.layer(),
+);
+
+const OperationRegistrySpec = LayerSpec.make(
+  {
+    affinity: 'space',
+    requires: [Database.Service, OperationHandlerSet.OperationHandlerProvider],
+    provides: [OperationRegistry.Service],
+  },
+  () => OperationRegistry.layer,
+);
+
+/**
+ * In-memory trigger state. Loses state across restarts but works in both
+ * browser and CLI/Node contexts. Hosts that need durable storage should
+ * contribute a replacement LayerSpec that provides {@link TriggerStateStore}
+ * backed by a persistent `KeyValueStore` (e.g. `BrowserKeyValueStore` or
+ * `BunKeyValueStore`).
+ */
+const TriggerStateStoreSpec = LayerSpec.make(
+  {
+    affinity: 'application',
+    requires: [],
+    provides: [TriggerStateStore],
+  },
+  () => TriggerStateStore.layerMemory,
+);
+
+//
+// Space-affinity specs.
+//
+
+const FeedTraceSinkSpec = LayerSpec.make(
+  {
+    affinity: 'space',
+    requires: [Database.Service, Feed.FeedService],
+    provides: [FeedTraceSink.FeedTraceSink],
+  },
+  () => FeedTraceSink.layerLive,
+);
+
+/**
+ * Space-scoped override of {@link RemoteFunctionExecutionService}. Activated
+ * only when the client's `runtime.client.edgeFeatures.agents` config is set;
+ * falls back to the application-level spec otherwise.
+ */
+const RemoteFunctionExecutionOverrideSpec = LayerSpec.make(
+  {
+    affinity: 'space',
+    requires: [ClientService],
+    provides: [RemoteFunctionExecutionService],
+  },
+  (context) =>
+    Layer.unwrapEffect(
+      Effect.gen(function* () {
+        invariant(context.space, 'space context required for RemoteFunctionExecutionService override');
+        const client = yield* ClientService;
+        return RemoteFunctionExecutionService.fromClient(client, context.space);
+      }),
+    ),
+);
+
+const TriggerDispatcherSpec = LayerSpec.make(
+  {
+    affinity: 'space',
+    requires: [
+      Database.Service,
+      QueueService,
+      TriggerStateStore,
+      ProcessManager.ProcessManagerService,
+      Registry.AtomRegistry,
+    ],
+    provides: [TriggerDispatcher],
+  },
+  () => TriggerDispatcher.layer({ timeControl: 'natural' }),
+);
+
+export default Capability.makeModule(
+  Effect.fnUntraced(function* () {
+    const client = yield* Capability.get(ClientCapabilities.Client);
+
+    const contributions: Capability.Any[] = [
+      Capability.contributes(Capabilities.LayerSpec, OperationHandlerProviderSpec),
+      Capability.contributes(Capabilities.LayerSpec, BlueprintRegistrySpec),
+      Capability.contributes(Capabilities.LayerSpec, OpaqueToolkitSpec),
+      Capability.contributes(Capabilities.LayerSpec, AgentServiceSpec),
+      Capability.contributes(Capabilities.LayerSpec, OperationRegistrySpec),
+      Capability.contributes(Capabilities.LayerSpec, TriggerStateStoreSpec),
+      Capability.contributes(Capabilities.LayerSpec, FeedTraceSinkSpec),
+      Capability.contributes(Capabilities.LayerSpec, TriggerDispatcherSpec),
+      Capability.contributes(Capabilities.TraceSink, ({ resolver }) => FeedTraceSink.makeRoutingSink({ resolver })),
+      // Edge-mode override is conditional on runtime config, so it stays in the
+      // activation block.
+      Capability.contributes(
+        Capabilities.LayerSpec,
+        client.config.get('runtime.client.edgeFeatures.agents')
+          ? RemoteFunctionExecutionSpec
+          : RemoteFunctionExecutionOverrideSpec,
+      ),
+    ];
+
+    return contributions;
+  }),
+);

package/src/capabilities/node.ts

@@ -0,0 +1,13 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Capability } from '@dxos/app-framework';
+import { OperationHandlerSet } from '@dxos/compute';
+
+export const AppGraphBuilder = Capability.lazy('AppGraphBuilder', () => import('./app-graph-builder'));
+export const LayerSpecs = Capability.lazy<void, Capability.Any[]>('LayerSpecs', () => import('./layer-specs'));
+export const OperationHandler = Capability.lazy<OperationHandlerSet.OperationHandlerSet>(
+  'OperationHandler',
+  () => import('./operation-handler'),
+);

package/src/capabilities/operation-handler.ts

@@ -0,0 +1,16 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Capabilities, Capability } from '@dxos/app-framework';
+import type { OperationHandlerSet } from '@dxos/compute';
+
+import { AutomationOperationHandlerSet } from '#operations';
+
+export default Capability.makeModule<OperationHandlerSet.OperationHandlerSet>(
+  Effect.fnUntraced(function* () {
+    return Capability.contributes(Capabilities.OperationHandler, AutomationOperationHandlerSet);
+  }),
+);

package/src/capabilities/react-surface.tsx

@@ -2,55 +2,58 @@
 // Copyright 2025 DXOS.org
 //
 
+import * as Effect from 'effect/Effect';
 import React from 'react';
 
-import { Capabilities, contributes, createSurface } from '@dxos/app-framework';
-import { useLayout } from '@dxos/app-framework/react';
-import { Obj } from '@dxos/echo';
-import { getSpace, parseId, useSpace } from '@dxos/react-client/echo';
+import { Capabilities, Capability } from '@dxos/app-framework';
+import { Surface } from '@dxos/app-framework/ui';
+import { AppSurface, useActiveSpace } from '@dxos/app-toolkit/ui';
+import { getSpace } from '@dxos/react-client/echo';
 
-import { AutomationSettings, 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-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) {
-          return null;
-        }
+export default Capability.makeModule(() =>
+  Effect.succeed(
+    Capability.contributes(Capabilities.ReactSurface, [
+      Surface.create({
+        id: 'space-settings-functions',
+        filter: AppSurface.literal(AppSurface.Article, `${meta.id}.space-settings-functions`),
+        component: () => {
+          const space = useActiveSpace();
+          if (!space) {
+            return null;
+          }
 
-        return <FunctionsContainer space={space} />;
-      },
-    }),
-    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) {
-          return null;
-        }
+          return <FunctionsContainer space={space} />;
+        },
+      }),
+      Surface.create({
+        id: 'space-settings-automation',
+        filter: AppSurface.literal(AppSurface.Article, `${meta.id}.space-settings-automation`),
+        component: () => {
+          const space = useActiveSpace();
+          if (!space) {
+            return null;
+          }
 
-        return <AutomationSettings space={space} />;
-      },
-    }),
-    createSurface({
-      id: `${meta.id}/companion/automation`,
-      role: 'article',
-      filter: (data): data is { companionTo: Obj.Any; subject: 'automation' } =>
-        Obj.isObject(data.companionTo) && data.subject === 'automation',
-      component: ({ data }) => {
-        return <AutomationSettings space={getSpace(data.companionTo)!} object={data.companionTo} />;
-      },
-    }),
-  ]);
+          return <AutomationSettings space={space} />;
+        },
+      }),
+      Surface.create({
+        id: 'companion.automation',
+        filter: AppSurface.allOf(
+          AppSurface.literal(AppSurface.Article, 'automation'),
+          AppSurface.companion(AppSurface.Article),
+        ),
+        component: ({ data }) => {
+          const space = getSpace(data.companionTo);
+          if (!space) {
+            return null;
+          }
+          return <AutomationSettings space={space} object={data.companionTo} />;
+        },
+      }),
+    ]),
+  ),
+);

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,86 @@
+//
+// 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 { Enabled, Input, Queue } from '../options';
+import { printTrigger, promptForSchemaInput, selectFunction, selectFeed } 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: () => selectFeed(),
+        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: Trigger.specQueue(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/commands/trigger/create/subscription.ts

@@ -0,0 +1,125 @@
+//
+// 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 { 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 subscriptionQuery = Query.select(Filter.type(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)),
+);