@dxos/plugin-routine 0.0.0

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

@@ -0,0 +1,191 @@
+//
+// 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 { Operation, Trigger } from '@dxos/compute';
+import { Database, Filter, JsonSchema, Obj, Ref, Feed as Feed$ } from '@dxos/echo';
+import { EID, type EntityId } from '@dxos/keys';
+
+import { Enabled, Feed, Input, TriggerId } from '../options';
+import { printTrigger, promptForSchemaInput, selectFeed, selectFunction, selectTrigger } from '../util';
+
+export const queue = Command.make(
+  'feed',
+  {
+    spaceId: Common.spaceId.pipe(Options.optional),
+    id: TriggerId.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 triggerId = yield* Option.match(options.id, {
+        onNone: () => selectTrigger('feed'),
+        onSome: (id) => Effect.succeed(id),
+      });
+      const dxn = EID.make({ entityId: triggerId as EntityId });
+      const trigger = yield* Database.resolve(dxn, Trigger.Trigger);
+      if (trigger.spec?.kind !== 'feed') {
+        return yield* Effect.fail(new Error(`Invalid trigger type: ${trigger.spec?.kind}`));
+      }
+
+      const currentFn = yield* updateFunction(trigger, options.functionId);
+      yield* updateFeed(trigger, options.feed);
+      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 feed 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.runnable
+    ? yield* Database.load(trigger.runnable)
+    : 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.query(Filter.type(Operation.PersistentOperation)).run;
+    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.update(trigger, (trigger) => {
+      trigger.runnable = Ref.make(foundFn);
+    });
+    currentFn = foundFn;
+  }
+
+  if (!currentFn) {
+    const runnableId = (trigger.runnable ? trigger.runnable.uri.toString() : undefined) ?? 'unknown';
+    return yield* Effect.fail(new Error(`Invalid reference for ${runnableId}`));
+  }
+
+  return currentFn;
+});
+
+/**
+ * Handles updating the feed reference for a feed trigger.
+ * Prompts for confirmation if feed is not provided, then updates the feed if confirmed.
+ */
+const updateFeed = Effect.fn(function* (trigger: Trigger.Trigger, feedOption: Option.Option<string>) {
+  const currentFeed = trigger.spec?.kind === 'feed' ? trigger.spec.feed : undefined;
+  const currentFeedStr = currentFeed ? currentFeed.uri.toString() : undefined;
+  const shouldChangeFeed = yield* Option.match(feedOption, {
+    onNone: () =>
+      Prompt.confirm({
+        message: `Change the feed${currentFeedStr ? ` (current: ${currentFeedStr})` : ''}?`,
+        initial: false,
+      }).pipe(Prompt.run),
+    onSome: () => Effect.succeed(true),
+  });
+  if (shouldChangeFeed) {
+    const feed = yield* Option.match(feedOption, {
+      onNone: () => selectFeed(),
+      onSome: (uri) => Database.resolve(EID.parse(uri), Feed$.Feed),
+    });
+    Obj.update(trigger, (trigger) => {
+      if (trigger.spec?.kind === 'feed') {
+        trigger.spec.feed = Ref.make(feed);
+      }
+    });
+  }
+});
+
+/**
+ * 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.update(trigger, (trigger) => {
+      trigger.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.update(trigger, (trigger) => {
+    trigger.enabled = enabledValue;
+  });
+});

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

@@ -0,0 +1,278 @@
+//
+// 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 Match from 'effect/Match';
+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, Obj, Query, Ref } from '@dxos/echo';
+import { DXN, EID } from '@dxos/keys';
+
+import { Deep, Delay, Enabled, Input, TriggerId, Typename } from '../options';
+import { printTrigger, promptForSchemaInput, selectFunction, selectTrigger } from '../util';
+
+export const subscription = Command.make(
+  'subscription',
+  {
+    spaceId: Common.spaceId.pipe(Options.optional),
+    id: TriggerId.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 triggerId = yield* Option.match(options.id, {
+        onNone: () => selectTrigger('subscription'),
+        onSome: (id) => Effect.succeed(id),
+      });
+      const dxn = EID.make({ entityId: triggerId });
+      const trigger = yield* Database.resolve(Ref.fromURI(dxn), Trigger.Trigger);
+      if (trigger.spec?.kind !== 'subscription') {
+        return yield* Effect.fail(new Error(`Invalid trigger type: ${trigger.spec?.kind}`));
+      }
+
+      const currentFn = yield* updateFunction(trigger, options.functionId);
+      yield* updateSpec(trigger, options.typename, options.deep, options.delay);
+      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 subscription trigger.'),
+  Command.provide(({ spaceId }) => spaceLayer(spaceId, true)),
+  Command.provideEffectDiscard(() => withTypes(Operation.PersistentOperation, Trigger.Trigger)),
+);
+
+/**
+ * Extracts the current typename from a subscription trigger's query AST.
+ */
+const extractCurrentTypename = (spec: Trigger.SubscriptionSpec | undefined): Option.Option<string> => {
+  if (!spec?.query?.ast) {
+    return Option.none();
+  }
+  return Match.value(spec.query.ast).pipe(
+    Match.withReturnType<Option.Option<string>>(),
+    Match.when({ type: 'select' }, (q) =>
+      Match.value(q.filter).pipe(
+        Match.withReturnType<Option.Option<string>>(),
+        Match.when({ type: 'object' }, (f) =>
+          Option.fromNullable(f.typename).pipe(
+            Option.flatMap((dxn) => Option.fromNullable(DXN.isDXN(dxn) ? DXN.getName(dxn) : undefined)),
+          ),
+        ),
+        Match.orElse(() => Option.none()),
+      ),
+    ),
+    Match.orElse(() => Option.none()),
+  );
+};
+
+/**
+ * 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.runnable
+    ? yield* Database.load(trigger.runnable)
+    : 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.query(Filter.type(Operation.PersistentOperation)).run;
+    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.update(trigger, (trigger) => {
+      trigger.runnable = Ref.make(foundFn);
+    });
+    currentFn = foundFn;
+  }
+
+  if (!currentFn) {
+    const runnableId = trigger.runnable?.uri.toString() ?? 'unknown';
+    return yield* Effect.fail(new Error(`Invalid reference for ${runnableId}`));
+  }
+
+  return currentFn;
+});
+
+/**
+ * Handles updating the subscription trigger spec (typename, deep, delay).
+ * Prompts for confirmation if no spec options are provided, then updates the spec if confirmed.
+ */
+const updateSpec = Effect.fn(function* (
+  trigger: Trigger.Trigger,
+  typenameOption: Option.Option<string>,
+  deepOption: Option.Option<boolean>,
+  delayOption: Option.Option<number>,
+) {
+  const currentSpec = trigger.spec?.kind === 'subscription' ? trigger.spec : undefined;
+  const currentTypename = extractCurrentTypename(currentSpec);
+  const currentTypenameStr = Option.getOrUndefined(currentTypename);
+  const currentDeep = currentSpec?.options?.deep;
+  const currentDelay = currentSpec?.options?.delay;
+  const specParts: string[] = [];
+  if (currentTypenameStr) {
+    specParts.push(`typename: ${currentTypenameStr}`);
+  }
+  if (currentDeep !== undefined) {
+    specParts.push(`deep: ${currentDeep}`);
+  }
+  if (currentDelay !== undefined) {
+    specParts.push(`delay: ${currentDelay}`);
+  }
+  const currentSpecStr = specParts.length > 0 ? specParts.join(', ') : 'none';
+
+  const hasSpecOption = Option.isSome(typenameOption) || Option.isSome(deepOption) || Option.isSome(delayOption);
+  const shouldChangeSpec = yield* hasSpecOption
+    ? Effect.succeed(true)
+    : Prompt.confirm({
+        message: `Change the trigger spec (current: ${currentSpecStr})?`,
+        initial: false,
+      }).pipe(Prompt.run);
+  if (shouldChangeSpec) {
+    const typename = yield* Option.match(typenameOption, {
+      onNone: () =>
+        Prompt.text({
+          message: `Enter type name${currentTypenameStr ? ` (current: ${currentTypenameStr})` : ''}:`,
+        }).pipe(Prompt.run),
+      onSome: (value) => Effect.succeed(value),
+    });
+    const queryAst = Query.select(Filter.type(DXN.make(typename))).ast;
+
+    const deepOptionValue = yield* Option.match(deepOption, {
+      onNone: () =>
+        Prompt.confirm({
+          message: 'Watch changes to nested properties (deep)?',
+          initial: currentSpec?.options?.deep ?? false,
+        }).pipe(
+          Prompt.run,
+          Effect.map((value) => (value ? Option.some(value) : Option.none())),
+        ),
+      onSome: () => Effect.succeed(Option.some(true)),
+    });
+
+    const delayOptionValue = yield* Option.match(delayOption, {
+      onNone: () =>
+        Effect.gen(function* () {
+          const currentDelay = currentSpec?.options?.delay;
+          const delayStr = yield* Prompt.text({
+            message: `Debounce delay in milliseconds (optional, press Enter to skip)${currentDelay ? ` (current: ${currentDelay})` : ''}:`,
+          }).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(deepOptionValue)) {
+      subscriptionOptions.deep = deepOptionValue.value;
+    }
+    if (Option.isSome(delayOptionValue)) {
+      subscriptionOptions.delay = delayOptionValue.value;
+    }
+
+    Obj.update(trigger, (trigger) => {
+      const spec = trigger.spec;
+      if (spec?.kind === 'subscription') {
+        // Cast needed because QueryAST types are deeply readonly but spec.query expects mutable.
+        spec.query = { ast: queryAst } as NonNullable<typeof spec.query>;
+        spec.options = Object.keys(subscriptionOptions).length > 0 ? subscriptionOptions : undefined;
+      }
+    });
+  }
+});
+
+/**
+ * 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.update(trigger, (trigger) => {
+      trigger.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.update(trigger, (trigger) => {
+    trigger.enabled = enabledValue;
+  });
+});

package/src/commands/trigger/update/timer.ts

@@ -0,0 +1,194 @@
+//
+// 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 { Operation, Trigger } from '@dxos/compute';
+import { Database, Filter, JsonSchema, Obj, Ref } from '@dxos/echo';
+import { EID } from '@dxos/keys';
+
+import { Cron, Enabled, Input, TriggerId } from '../options';
+import { printTrigger, promptForSchemaInput, selectFunction, selectTrigger } from '../util';
+
+export const timer = Command.make(
+  'timer',
+  {
+    spaceId: Common.spaceId.pipe(Options.optional),
+    id: TriggerId.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 triggerId = yield* Option.match(options.id, {
+        onNone: () => selectTrigger('timer'),
+        onSome: (id) => Effect.succeed(id),
+      });
+      const dxn = EID.make({ entityId: triggerId });
+      const trigger = yield* Database.resolve(Ref.fromURI(dxn), Trigger.Trigger);
+      if (!trigger.spec || trigger.spec?.kind !== 'timer') {
+        return yield* Effect.fail(new Error(`Invalid trigger type: ${trigger.spec?.kind}`));
+      }
+
+      const currentFn = yield* updateFunction(trigger, options.functionId);
+      yield* updateCron(trigger, options.cron);
+      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 timer 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.runnable
+    ? yield* Database.load(trigger.runnable)
+    : 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.query(Filter.type(Operation.PersistentOperation)).run;
+    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.update(trigger, (trigger) => {
+      trigger.runnable = Ref.make(foundFn);
+    });
+    currentFn = foundFn;
+  }
+
+  if (!currentFn) {
+    const runnableId = trigger.runnable?.uri.toString() ?? 'unknown';
+    return yield* Effect.fail(new Error(`Invalid reference for ${runnableId}`));
+  }
+
+  return currentFn;
+});
+
+/**
+ * Handles updating the cron expression for a timer trigger.
+ * Prompts for confirmation if cron is not provided, then updates the cron if confirmed.
+ */
+const updateCron = Effect.fn(function* (trigger: Trigger.Trigger, cronOption: Option.Option<string>) {
+  const currentCron = trigger.spec?.kind === 'timer' ? trigger.spec.cron : undefined;
+  const shouldChangeCron = yield* Option.match(cronOption, {
+    onNone: () =>
+      Prompt.confirm({
+        message: `Change the cron expression${currentCron ? ` (current: ${currentCron})` : ''}?`,
+        initial: false,
+      }).pipe(Prompt.run),
+    onSome: () => Effect.succeed(true),
+  });
+  if (shouldChangeCron) {
+    const cron = yield* Option.match(cronOption, {
+      onNone: () =>
+        Prompt.text({
+          message: `Enter cron expression${currentCron ? ` (current: ${currentCron})` : ''}:`,
+        }).pipe(Prompt.run),
+      onSome: (value) => Effect.succeed(value),
+    });
+    Obj.update(trigger, (trigger) => {
+      if (trigger.spec?.kind === 'timer') {
+        trigger.spec.cron = cron;
+      }
+    });
+  }
+});
+
+/**
+ * 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.update(trigger, (trigger) => {
+      trigger.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.update(trigger, (trigger) => {
+    trigger.enabled = enabledValue;
+  });
+});