@dxos/plugin-automation 0.8.4-main.dedc0f3 → 0.8.4-main.dfabb4ec29

package/dist/lib/neutral/AutomationPlugin.node.mjs

@@ -0,0 +1,1113 @@
+import "./chunk-J5LGTIGS.mjs";
+
+// src/AutomationPlugin.node.ts
+import { Plugin } from "@dxos/app-framework";
+import { AppPlugin } from "@dxos/app-toolkit";
+import { Operation as Operation8, Trace, Trigger as Trigger10 } from "@dxos/compute";
+import { ClientEvents } from "@dxos/plugin-client";
+import { AppGraphBuilder, ComputeRuntime, OperationHandler } from "#capabilities";
+import { meta } from "#meta";
+import { AutomationEvents } from "#types";
+
+// src/commands/trigger/index.ts
+import * as Command11 from "@effect/cli/Command";
+
+// src/commands/trigger/create/index.ts
+import * as Command4 from "@effect/cli/Command";
+
+// src/commands/trigger/create/queue.ts
+import * as Command from "@effect/cli/Command";
+import * as Options2 from "@effect/cli/Options";
+import * as Prompt2 from "@effect/cli/Prompt";
+import * as Console2 from "effect/Console";
+import * as Effect2 from "effect/Effect";
+import * as HashMap from "effect/HashMap";
+import * as Option2 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 as Operation2, Trigger as Trigger2 } from "@dxos/compute";
+import { Database as Database2, Filter as Filter2, JsonSchema, Ref as Ref2 } from "@dxos/echo";
+
+// src/commands/trigger/options.ts
+import * as Options from "@effect/cli/Options";
+import * as Schema from "effect/Schema";
+import { DXN } from "@dxos/keys";
+var TriggerId = Options.text("id").pipe(Options.withDescription("The id of the trigger."));
+var Enabled = Options.boolean("enabled", {
+  ifPresent: true
+}).pipe(Options.withDescription("Whether the trigger is enabled."));
+var Input = Options.keyValueMap("input").pipe(Options.withDescription("Input data to pass to the function. Must match the function's input schema."));
+var Typename = Options.text("typename").pipe(Options.withDescription("The type name to query for the subscription trigger."));
+var Deep = Options.boolean("deep", {
+  ifPresent: true
+}).pipe(Options.withDescription("Watch changes to nested properties (not just creation)."));
+var Delay = Options.integer("delay").pipe(Options.withDescription("Debounce changes with a delay in milliseconds."));
+var Cron = Options.text("cron").pipe(Options.withDescription("The cron expression to use for the timer trigger."));
+var DXNSchema = Schema.String.pipe(Schema.transform(Schema.instanceOf(DXN), {
+  decode: (value2) => DXN.parse(value2),
+  encode: (value2) => value2.toString()
+}));
+var Queue = Options.text("queue").pipe(Options.withDescription("The DXN of the queue for the queue trigger."), Options.withSchema(DXNSchema));
+
+// src/commands/trigger/util.ts
+import * as Prompt from "@effect/cli/Prompt";
+import * as Ansi from "@effect/printer-ansi/Ansi";
+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 * as SchemaAST from "effect/SchemaAST";
+import { FormBuilder } from "@dxos/cli-util";
+import { Operation, Trigger } from "@dxos/compute";
+import { Annotation, Database, Entity, Feed, Filter, Obj, Query, Ref, Type } from "@dxos/echo";
+import { getProperties } from "@dxos/effect";
+import { FeedAnnotation } from "@dxos/schema";
+var getTriggerRemoteStatus = (trigger2, remoteCronIds) => {
+  if (trigger2.spec?.kind !== "timer") {
+    return "n/a";
+  }
+  return remoteCronIds.includes(trigger2.id) ? "available" : "not available";
+};
+var printTrigger = Effect.fn(function* (trigger2, remoteStatus) {
+  const fn6 = trigger2.function && (yield* Database.load(trigger2.function));
+  return FormBuilder.make({
+    title: trigger2.id
+  }).pipe(FormBuilder.set("status", trigger2.enabled ? "enabled" : "disabled", trigger2.enabled ? Ansi.green : Ansi.blackBright), FormBuilder.option("kind", Option.fromNullable(trigger2.spec?.kind)), FormBuilder.option("remote", Option.fromNullable(remoteStatus), Match.type().pipe(Match.withReturnType(), Match.when("available", () => Ansi.green), Match.when("not available", () => Ansi.yellow), Match.when("n/a", () => Ansi.blackBright), Match.exhaustive)), FormBuilder.when(fn6, FormBuilder.nest("function", FormBuilder.make().pipe(FormBuilder.set("key", fn6.key), FormBuilder.set("dxn", Obj.getDXN(fn6).toString())))), FormBuilder.nestedOption("spec", Option.fromNullable(trigger2.spec).pipe(Option.map(printSpec))), FormBuilder.build);
+});
+var printSpec = (spec) => {
+  switch (spec.kind) {
+    case "timer":
+      return printTimer(spec);
+    case "subscription":
+      return printSubscription(spec);
+    case "webhook":
+      return printWebhook(spec);
+    case "queue":
+      return printQueue(spec);
+    default:
+      return FormBuilder.make({}).pipe(FormBuilder.set("unknown", "Unknown spec type"));
+  }
+};
+var printTimer = (spec) => FormBuilder.make({}).pipe(FormBuilder.set("cron", spec.cron));
+var printSubscription = (spec) => FormBuilder.make({}).pipe(FormBuilder.set("query", spec.query?.raw ?? "[Query AST]"));
+var printWebhook = (spec) => FormBuilder.make({}).pipe(FormBuilder.set("method", spec.method), FormBuilder.set("port", spec.port));
+var printQueue = (spec) => FormBuilder.make({}).pipe(FormBuilder.set("queue", spec.queue));
+var promptForSchemaInput = Effect.fn(function* (schema, defaults) {
+  if (!schema) {
+    return {};
+  }
+  const ast = schema.ast;
+  if (!SchemaAST.isTypeLiteral(ast)) {
+    return {};
+  }
+  const properties = getProperties(ast);
+  if (properties.length === 0) {
+    return {};
+  }
+  const requiredProperties = [];
+  const optionalProperties = [];
+  for (const prop of properties) {
+    if (prop.isOptional) {
+      optionalProperties.push(prop);
+    } else {
+      requiredProperties.push(prop);
+    }
+  }
+  const propertyInfo = properties.map((prop) => {
+    const key = prop.name.toString();
+    return {
+      prop,
+      key,
+      isRequired: !prop.isOptional
+    };
+  });
+  const selectedKeys = /* @__PURE__ */ new Set();
+  for (const info of propertyInfo) {
+    if (info.isRequired) {
+      selectedKeys.add(info.key);
+    }
+  }
+  if (requiredProperties.length > 0) {
+    const requiredNames = requiredProperties.map((p) => {
+      const info = propertyInfo.find((i) => i.prop === p);
+      return info?.key ?? p.name.toString();
+    });
+    yield* Console.log(`Required properties (will be included): ${requiredNames.join(", ")}`);
+  }
+  if (optionalProperties.length > 0) {
+    const optionalInfo = propertyInfo.filter((info) => !info.isRequired);
+    const choices = optionalInfo.map((info) => {
+      const hasDefault = defaults?.[info.key] !== void 0;
+      const defaultText = hasDefault ? ` (current: ${JSON.stringify(defaults[info.key])})` : "";
+      return {
+        title: `${info.key}${defaultText}`,
+        value: info.key,
+        description: hasDefault ? "Has default value" : void 0
+      };
+    });
+    const selected = yield* Prompt.multiSelect({
+      message: "Select optional properties to include:",
+      choices
+    });
+    for (const key of selected) {
+      selectedKeys.add(String(key));
+    }
+  }
+  if (selectedKeys.size === 0) {
+    return {};
+  }
+  const inputObj = {};
+  for (const info of propertyInfo) {
+    if (!selectedKeys.has(info.key)) {
+      continue;
+    }
+    const key = info.key;
+    const propType = info.prop.type;
+    const schemaDefault = Option.getOrUndefined(SchemaAST.getDefaultAnnotation(propType));
+    const defaultValue = defaults?.[key] ?? schemaDefault;
+    if (SchemaAST.isBooleanKeyword(propType)) {
+      const initialValue = typeof defaultValue === "boolean" ? defaultValue : typeof schemaDefault === "boolean" ? schemaDefault : false;
+      const value2 = yield* Prompt.confirm({
+        message: `${info.key}${defaults?.[key] !== void 0 ? ` (current: ${defaults[key]})` : ""}:`,
+        initial: initialValue
+      });
+      inputObj[key] = value2;
+    } else if (SchemaAST.isNumberKeyword(propType)) {
+      const currentValue = typeof defaultValue === "number" ? String(defaultValue) : "";
+      const valueStr = yield* Prompt.text({
+        message: `${info.key}${currentValue ? ` (current: ${currentValue}, press Enter to keep)` : ""}:`
+      }).pipe(Prompt.run);
+      inputObj[key] = valueStr === "" && defaultValue !== void 0 ? defaultValue : parseFloat(valueStr) || 0;
+    } else if (SchemaAST.isStringKeyword(propType)) {
+      const currentValue = typeof defaultValue === "string" ? defaultValue : "";
+      const valueStr = yield* Prompt.text({
+        message: `${info.key}${currentValue ? ` (current: ${currentValue}, press Enter to keep)` : ""}:`
+      }).pipe(Prompt.run);
+      inputObj[key] = valueStr === "" && defaultValue !== void 0 ? defaultValue : valueStr;
+    } else if (Ref.isRefType(propType)) {
+      const isDefaultTemplate = typeof defaultValue === "string" && defaultValue.startsWith("{{") && defaultValue.endsWith("}}");
+      const useTemplate = yield* Prompt.confirm({
+        message: `Use a template to specify ${info.key}?${isDefaultTemplate ? " (current: template)" : ""}`,
+        initial: isDefaultTemplate
+      });
+      if (useTemplate) {
+        const currentValue = typeof defaultValue === "string" ? defaultValue : "";
+        const templateStr = yield* Prompt.text({
+          message: `${info.key} template${currentValue ? ` (current: ${currentValue}, press Enter to keep)` : ""}:`
+        }).pipe(Prompt.run);
+        inputObj[key] = templateStr === "" && defaultValue !== void 0 ? defaultValue : templateStr;
+      } else {
+        const annotation = Annotation.ReferenceAnnotation.getFromAst(propType).pipe(Option.getOrThrow);
+        const objects = yield* Database.runQuery(Filter.typename(annotation.typename));
+        if (objects.length === 0) {
+          inputObj[key] = void 0;
+        } else {
+          const selected = yield* Prompt.select({
+            message: `Select ${info.key}:`,
+            choices: objects.map((obj) => ({
+              title: Entity.getLabel(obj) ?? obj.id,
+              value: Ref.make(obj),
+              description: Entity.getDescription(obj)
+            }))
+          });
+          inputObj[key] = selected;
+        }
+      }
+    } else {
+      const currentValue = defaultValue !== void 0 ? String(defaultValue) : "";
+      const valueStr = yield* Prompt.text({
+        message: `${info.key}${currentValue ? ` (current: ${currentValue}, press Enter to keep)` : ""}:`
+      }).pipe(Prompt.run);
+      inputObj[key] = valueStr === "" && defaultValue !== void 0 ? defaultValue : valueStr;
+    }
+  }
+  return inputObj;
+});
+var selectFunction = Effect.fn(function* () {
+  const functions = yield* Database.runQuery(Filter.type(Operation.PersistentOperation));
+  if (functions.length === 0) {
+    return yield* Effect.fail(new Error("No functions available"));
+  }
+  const selected = yield* Prompt.select({
+    message: "Select a function:",
+    choices: functions.map((fn6) => ({
+      title: fn6.name ?? fn6.id,
+      value: fn6.id,
+      description: fn6.description
+    }))
+  });
+  return String(selected);
+});
+var selectTrigger = Effect.fn(function* (kind) {
+  const triggers = yield* Database.runQuery(Query.select(Filter.type(Trigger.Trigger)).debugLabel("cli.trigger.selectTrigger"));
+  const filteredTriggers = kind ? triggers.filter((trigger2) => trigger2.spec?.kind === kind) : triggers;
+  if (filteredTriggers.length === 0) {
+    return yield* Effect.fail(new Error(kind ? `No ${kind} triggers available` : "No triggers available"));
+  }
+  const choices = yield* Effect.all(filteredTriggers.map((trigger2) => Effect.gen(function* () {
+    const fn6 = trigger2.function ? yield* Database.load(trigger2.function) : void 0;
+    const functionName = fn6 && Obj.instanceOf(Operation.PersistentOperation, fn6) ? fn6.name ?? fn6.key ?? fn6.id : void 0;
+    const title = functionName ?? trigger2.id;
+    const description = `${trigger2.enabled ? "enabled" : "disabled"} - ${trigger2.spec?.kind ?? "unknown"}`;
+    return {
+      title,
+      value: trigger2.id,
+      description
+    };
+  })));
+  const selected = yield* Prompt.select({
+    message: kind ? `Select a ${kind} trigger:` : "Select a trigger:",
+    choices
+  });
+  return String(selected);
+});
+var selectQueue = Effect.fn(function* () {
+  const schemas = yield* Database.runSchemaQuery({
+    location: [
+      "database",
+      "runtime"
+    ]
+  });
+  const feedSchemas = schemas.filter((schema) => {
+    const annotation = FeedAnnotation.get(schema);
+    return Option.isSome(annotation) && annotation.value === true;
+  });
+  if (feedSchemas.length === 0) {
+    return yield* Effect.fail(new Error("No schemas with Feed annotation found"));
+  }
+  const queueChoices = [];
+  for (const schema of feedSchemas) {
+    yield* Effect.gen(function* () {
+      const typename = Type.getTypename(schema);
+      const objects = yield* Database.runQuery(Filter.type(typename));
+      for (const obj of objects) {
+        const feedRef = obj.feed;
+        if (!feedRef) {
+          continue;
+        }
+        const feedObj = yield* Effect.promise(() => feedRef.tryLoad());
+        if (!feedObj || !Obj.instanceOf(Feed.Feed, feedObj)) {
+          continue;
+        }
+        const queueDxn = Feed.getQueueDxn(feedObj);
+        if (!queueDxn) {
+          continue;
+        }
+        const label = Obj.getLabel(obj) ?? obj.id;
+        const description = Obj.getTypename(obj);
+        queueChoices.push({
+          title: label,
+          value: queueDxn.toString(),
+          description
+        });
+      }
+    }).pipe(Effect.catchAll(() => Effect.void));
+  }
+  if (queueChoices.length === 0) {
+    return yield* Effect.fail(new Error("No objects with queue properties found"));
+  }
+  const selected = yield* Prompt.select({
+    message: "Select a queue:",
+    choices: queueChoices
+  });
+  return String(selected);
+});
+var printTriggerRemoved = (id) => FormBuilder.make({
+  title: "Trigger removed"
+}).pipe(FormBuilder.set("id", id), FormBuilder.build);
+
+// src/commands/trigger/create/queue.ts
+var queue = Command.make("queue", {
+  spaceId: Common.spaceId.pipe(Options2.optional),
+  enabled: Enabled,
+  functionId: Common.functionId.pipe(Options2.optional),
+  queue: Queue.pipe(Options2.optional),
+  input: Input.pipe(Options2.optional)
+}, (options) => Effect2.gen(function* () {
+  const { json } = yield* CommandConfig;
+  const functionId = yield* Option2.match(options.functionId, {
+    onNone: () => selectFunction(),
+    onSome: (id) => Effect2.succeed(id)
+  });
+  const functions = yield* Database2.runQuery(Filter2.type(Operation2.PersistentOperation));
+  const fn6 = functions.find((fn7) => fn7.id === functionId);
+  if (!fn6) {
+    return yield* Effect2.fail(new Error(`Function not found: ${functionId}`));
+  }
+  const queueDxn = yield* Option2.match(options.queue, {
+    onNone: () => selectQueue(),
+    onSome: (dxn) => Effect2.succeed(dxn.toString())
+  });
+  const input = yield* Option2.match(options.input, {
+    onNone: () => promptForSchemaInput(fn6.inputSchema ? JsonSchema.toEffectSchema(fn6.inputSchema) : void 0),
+    onSome: (value2) => Effect2.succeed(Object.fromEntries(HashMap.toEntries(value2)))
+  });
+  const enabled = yield* Option2.match(options.functionId, {
+    onNone: () => Prompt2.confirm({
+      message: "Enable the trigger?",
+      initial: true
+    }).pipe(Prompt2.run),
+    onSome: () => Effect2.succeed(options.enabled)
+  });
+  const trigger2 = Trigger2.make({
+    function: Ref2.make(fn6),
+    enabled,
+    spec: Trigger2.specQueue(queueDxn),
+    input
+  });
+  yield* Database2.add(trigger2);
+  if (json) {
+    yield* Console2.log(JSON.stringify(trigger2, null, 2));
+  } else {
+    yield* Console2.log(print(yield* printTrigger(trigger2)));
+  }
+  yield* flushAndSync({
+    indexes: true
+  });
+})).pipe(Command.withDescription("Create a queue trigger."), Command.provide(({ spaceId }) => spaceLayer(spaceId, true)), Command.provideEffectDiscard(() => withTypes(Operation2.PersistentOperation, Trigger2.Trigger)));
+
+// src/commands/trigger/create/subscription.ts
+import * as Command2 from "@effect/cli/Command";
+import * as Options3 from "@effect/cli/Options";
+import * as Prompt3 from "@effect/cli/Prompt";
+import * as Console3 from "effect/Console";
+import * as Effect3 from "effect/Effect";
+import * as HashMap2 from "effect/HashMap";
+import * as Option3 from "effect/Option";
+import { CommandConfig as CommandConfig2 } from "@dxos/cli-util";
+import { flushAndSync as flushAndSync2, print as print2, spaceLayer as spaceLayer2, withTypes as withTypes2 } from "@dxos/cli-util";
+import { Common as Common2 } from "@dxos/cli-util";
+import { Operation as Operation3, Trigger as Trigger3 } from "@dxos/compute";
+import { Database as Database3, Filter as Filter3, JsonSchema as JsonSchema2, Query as Query2, Ref as Ref3 } from "@dxos/echo";
+var subscription = Command2.make("subscription", {
+  spaceId: Common2.spaceId.pipe(Options3.optional),
+  enabled: Enabled,
+  functionId: Common2.functionId.pipe(Options3.optional),
+  typename: Typename.pipe(Options3.optional),
+  deep: Deep.pipe(Options3.optional),
+  delay: Delay.pipe(Options3.optional),
+  input: Input.pipe(Options3.optional)
+}, (options) => Effect3.gen(function* () {
+  const { json } = yield* CommandConfig2;
+  const functionId = yield* Option3.match(options.functionId, {
+    onNone: () => selectFunction(),
+    onSome: (id) => Effect3.succeed(id)
+  });
+  const functions = yield* Database3.runQuery(Filter3.type(Operation3.PersistentOperation));
+  const fn6 = functions.find((fn7) => fn7.id === functionId);
+  if (!fn6) {
+    return yield* Effect3.fail(new Error(`Function not found: ${functionId}`));
+  }
+  const typename = yield* Option3.match(options.typename, {
+    onNone: () => Prompt3.text({
+      message: "Enter type name:"
+    }).pipe(Prompt3.run),
+    onSome: (value2) => Effect3.succeed(value2)
+  });
+  const subscriptionQuery = Query2.select(Filter3.type(typename));
+  const deepOption = yield* Option3.match(options.deep, {
+    onNone: () => Prompt3.confirm({
+      message: "Watch changes to nested properties (deep)?",
+      initial: false
+    }).pipe(Prompt3.run, Effect3.map((value2) => value2 ? Option3.some(value2) : Option3.none())),
+    onSome: () => Effect3.succeed(Option3.some(true))
+  });
+  const delayOption = yield* Option3.match(options.delay, {
+    onNone: () => Effect3.gen(function* () {
+      const delayStr = yield* Prompt3.text({
+        message: "Debounce delay in milliseconds (optional, press Enter to skip):"
+      }).pipe(Prompt3.run);
+      return delayStr === "" ? Option3.none() : Option3.some(parseInt(delayStr, 10));
+    }),
+    onSome: (value2) => Effect3.succeed(Option3.some(value2))
+  });
+  const subscriptionOptions = {};
+  if (Option3.isSome(deepOption)) {
+    subscriptionOptions.deep = deepOption.value;
+  }
+  if (Option3.isSome(delayOption)) {
+    subscriptionOptions.delay = delayOption.value;
+  }
+  const input = yield* Option3.match(options.input, {
+    onNone: () => promptForSchemaInput(fn6.inputSchema ? JsonSchema2.toEffectSchema(fn6.inputSchema) : void 0),
+    onSome: (value2) => Effect3.succeed(Object.fromEntries(HashMap2.toEntries(value2)))
+  });
+  const enabled = yield* Option3.match(options.functionId, {
+    onNone: () => Prompt3.confirm({
+      message: "Enable the trigger?",
+      initial: true
+    }).pipe(Prompt3.run),
+    onSome: () => Effect3.succeed(options.enabled)
+  });
+  const trigger2 = Trigger3.make({
+    function: Ref3.make(fn6),
+    enabled,
+    spec: Trigger3.specSubscription(subscriptionQuery, Object.keys(subscriptionOptions).length > 0 ? subscriptionOptions : void 0),
+    input
+  });
+  yield* Database3.add(trigger2);
+  if (json) {
+    yield* Console3.log(JSON.stringify(trigger2, null, 2));
+  } else {
+    yield* Console3.log(print2(yield* printTrigger(trigger2)));
+  }
+  yield* flushAndSync2({
+    indexes: true
+  });
+})).pipe(Command2.withDescription("Create a subscription trigger."), Command2.provide(({ spaceId }) => spaceLayer2(spaceId, true)), Command2.provideEffectDiscard(() => withTypes2(Operation3.PersistentOperation, Trigger3.Trigger)));
+
+// src/commands/trigger/create/timer.ts
+import * as Command3 from "@effect/cli/Command";
+import * as Options4 from "@effect/cli/Options";
+import * as Prompt4 from "@effect/cli/Prompt";
+import * as Console4 from "effect/Console";
+import * as Effect4 from "effect/Effect";
+import * as HashMap3 from "effect/HashMap";
+import * as Option4 from "effect/Option";
+import { CommandConfig as CommandConfig3 } from "@dxos/cli-util";
+import { flushAndSync as flushAndSync3, print as print3, spaceLayer as spaceLayer3, withTypes as withTypes3 } from "@dxos/cli-util";
+import { Common as Common3 } from "@dxos/cli-util";
+import { Operation as Operation4, Trigger as Trigger4 } from "@dxos/compute";
+import { Database as Database4, Filter as Filter4, JsonSchema as JsonSchema3, Ref as Ref4 } from "@dxos/echo";
+var timer = Command3.make("timer", {
+  spaceId: Common3.spaceId.pipe(Options4.optional),
+  enabled: Enabled,
+  functionId: Common3.functionId.pipe(Options4.optional),
+  cron: Cron.pipe(Options4.optional),
+  input: Input.pipe(Options4.optional)
+}, (options) => Effect4.gen(function* () {
+  const { json } = yield* CommandConfig3;
+  const functionId = yield* Option4.match(options.functionId, {
+    onNone: () => selectFunction(),
+    onSome: (id) => Effect4.succeed(id)
+  });
+  const functions = yield* Database4.runQuery(Filter4.type(Operation4.PersistentOperation));
+  const fn6 = functions.find((fn7) => fn7.id === functionId);
+  if (!fn6) {
+    return yield* Effect4.fail(new Error(`Function not found: ${functionId}`));
+  }
+  const cron = yield* Option4.match(options.cron, {
+    onNone: () => Prompt4.text({
+      message: "Enter cron expression:"
+    }).pipe(Prompt4.run),
+    onSome: (value2) => Effect4.succeed(value2)
+  });
+  const input = yield* Option4.match(options.input, {
+    onNone: () => promptForSchemaInput(fn6.inputSchema ? JsonSchema3.toEffectSchema(fn6.inputSchema) : void 0),
+    onSome: (value2) => Effect4.succeed(Object.fromEntries(HashMap3.toEntries(value2)))
+  });
+  const enabled = yield* Option4.match(options.functionId, {
+    onNone: () => Prompt4.confirm({
+      message: "Enable the trigger?",
+      initial: true
+    }).pipe(Prompt4.run),
+    onSome: () => Effect4.succeed(options.enabled)
+  });
+  const trigger2 = Trigger4.make({
+    function: Ref4.make(fn6),
+    enabled,
+    spec: Trigger4.specTimer(cron),
+    input
+  });
+  yield* Database4.add(trigger2);
+  if (json) {
+    yield* Console4.log(JSON.stringify(trigger2, null, 2));
+  } else {
+    yield* Console4.log(print3(yield* printTrigger(trigger2)));
+  }
+  yield* flushAndSync3({
+    indexes: true
+  });
+})).pipe(Command3.withDescription("Create a timer trigger."), Command3.provide(({ spaceId }) => spaceLayer3(spaceId, true)), Command3.provideEffectDiscard(() => withTypes3(Operation4.PersistentOperation, Trigger4.Trigger)));
+
+// src/commands/trigger/create/index.ts
+var create = Command4.make("create").pipe(Command4.withDescription("Create a trigger."), Command4.withSubcommands([
+  subscription,
+  timer,
+  queue
+]));
+
+// src/commands/trigger/list.ts
+import * as Command5 from "@effect/cli/Command";
+import * as Options5 from "@effect/cli/Options";
+import * as Console5 from "effect/Console";
+import * as Effect5 from "effect/Effect";
+import { CommandConfig as CommandConfig4, Common as Common4, printList, spaceIdWithDefault, spaceLayer as spaceLayer4 } from "@dxos/cli-util";
+import { ClientService } from "@dxos/client";
+import { Trigger as Trigger5 } from "@dxos/compute";
+import { Context } from "@dxos/context";
+import { Database as Database5, Filter as Filter5, Query as Query3 } from "@dxos/echo";
+var __dxlog_file = "/__w/dxos/dxos/packages/plugins/plugin-automation/src/commands/trigger/list.ts";
+var list = Command5.make("list", {
+  spaceId: Common4.spaceId.pipe(Options5.optional)
+}, Effect5.fn(function* ({ spaceId: spaceIdOption }) {
+  const { json } = yield* CommandConfig4;
+  const triggers = yield* Database5.runQuery(Query3.select(Filter5.type(Trigger5.Trigger)).debugLabel("cli.trigger.list"));
+  const remoteCronIds = yield* Effect5.gen(function* () {
+    const client = yield* ClientService;
+    const spaceId = yield* spaceIdWithDefault(spaceIdOption);
+    const result = yield* Effect5.promise(() => client.edge.http.getCronTriggers(Context.default(void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 24 }), spaceId)).pipe(Effect5.catchAll(() => Effect5.succeed({
+      cronIds: []
+    })));
+    return result.cronIds;
+  });
+  const triggersWithStatus = triggers.map((trigger2) => ({
+    trigger: trigger2,
+    remoteStatus: getTriggerRemoteStatus(trigger2, remoteCronIds)
+  }));
+  if (json) {
+    yield* Console5.log(JSON.stringify(triggersWithStatus.map(({ trigger: trigger2, remoteStatus }) => ({
+      ...trigger2,
+      remoteStatus
+    })), null, 2));
+  } else {
+    if (triggersWithStatus.length === 0) {
+      yield* Console5.log("No triggers found.");
+    } else {
+      const items = yield* Effect5.all(triggersWithStatus.map(({ trigger: trigger2, remoteStatus }) => printTrigger(trigger2, remoteStatus)));
+      yield* Console5.log(printList(items));
+    }
+  }
+})).pipe(Command5.withDescription("List triggers configured on EDGE."), Command5.provide(({ spaceId }) => spaceLayer4(spaceId, true)));
+
+// src/commands/trigger/remove.ts
+import * as Command6 from "@effect/cli/Command";
+import * as Options6 from "@effect/cli/Options";
+import * as Console6 from "effect/Console";
+import * as Effect6 from "effect/Effect";
+import * as Option5 from "effect/Option";
+import { CommandConfig as CommandConfig5, Common as Common5, print as print4, spaceLayer as spaceLayer5, withTypes as withTypes4 } from "@dxos/cli-util";
+import { Trigger as Trigger6 } from "@dxos/compute";
+import { DXN as DXN2 } from "@dxos/echo";
+import { Database as Database6 } from "@dxos/echo";
+var remove = Command6.make("remove", {
+  spaceId: Common5.spaceId.pipe(Options6.optional),
+  id: TriggerId.pipe(Options6.optional)
+}, (options) => Effect6.gen(function* () {
+  const { json } = yield* CommandConfig5;
+  const triggerId = yield* Option5.match(options.id, {
+    onNone: () => selectTrigger(),
+    onSome: (id) => Effect6.succeed(id)
+  });
+  const dxn = DXN2.fromLocalObjectId(triggerId);
+  const trigger2 = yield* Database6.resolve(dxn, Trigger6.Trigger);
+  yield* Database6.remove(trigger2);
+  if (json) {
+    yield* Console6.log(JSON.stringify({
+      id: trigger2.id,
+      removed: true
+    }, null, 2));
+  } else {
+    yield* Console6.log(print4(printTriggerRemoved(trigger2.id)));
+  }
+})).pipe(Command6.withDescription("Remove a trigger."), Command6.provide(({ spaceId }) => spaceLayer5(spaceId, true)), Command6.provideEffectDiscard(() => withTypes4(Trigger6.Trigger)));
+
+// src/commands/trigger/update/index.ts
+import * as Command10 from "@effect/cli/Command";
+
+// src/commands/trigger/update/queue.ts
+import * as Command7 from "@effect/cli/Command";
+import * as Options7 from "@effect/cli/Options";
+import * as Prompt5 from "@effect/cli/Prompt";
+import * as Console7 from "effect/Console";
+import * as Effect7 from "effect/Effect";
+import * as Option6 from "effect/Option";
+import { CommandConfig as CommandConfig6 } from "@dxos/cli-util";
+import { flushAndSync as flushAndSync4, print as print5, spaceLayer as spaceLayer6, withTypes as withTypes5 } from "@dxos/cli-util";
+import { Common as Common6 } from "@dxos/cli-util";
+import { Operation as Operation5, Trigger as Trigger7 } from "@dxos/compute";
+import { DXN as DXN3, Database as Database7, Filter as Filter6, JsonSchema as JsonSchema4, Obj as Obj2, Ref as Ref5 } from "@dxos/echo";
+var queue2 = Command7.make("queue", {
+  spaceId: Common6.spaceId.pipe(Options7.optional),
+  id: TriggerId.pipe(Options7.optional),
+  enabled: Enabled,
+  functionId: Common6.functionId.pipe(Options7.optional),
+  queue: Queue.pipe(Options7.optional),
+  input: Input.pipe(Options7.optional)
+}, (options) => Effect7.gen(function* () {
+  const { json } = yield* CommandConfig6;
+  const triggerId = yield* Option6.match(options.id, {
+    onNone: () => selectTrigger("queue"),
+    onSome: (id) => Effect7.succeed(id)
+  });
+  const dxn = DXN3.fromLocalObjectId(triggerId);
+  const trigger2 = yield* Database7.resolve(dxn, Trigger7.Trigger);
+  if (trigger2.spec?.kind !== "queue") {
+    return yield* Effect7.fail(new Error(`Invalid trigger type: ${trigger2.spec?.kind}`));
+  }
+  const currentFn = yield* updateFunction(trigger2, options.functionId);
+  yield* updateQueue(trigger2, options.queue);
+  yield* updateInput(trigger2, currentFn, options.input);
+  yield* updateEnabled(trigger2, options.id, options.enabled);
+  if (json) {
+    yield* Console7.log(JSON.stringify(trigger2, null, 2));
+  } else {
+    yield* Console7.log(print5(yield* printTrigger(trigger2)));
+  }
+  yield* flushAndSync4({
+    indexes: true
+  });
+})).pipe(Command7.withDescription("Update a queue trigger."), Command7.provide(({ spaceId }) => spaceLayer6(spaceId, true)), Command7.provideEffectDiscard(() => withTypes5(Operation5.PersistentOperation, Trigger7.Trigger)));
+var updateFunction = Effect7.fn(function* (trigger2, functionIdOption) {
+  let currentFn = trigger2.function ? yield* Database7.load(trigger2.function) : void 0;
+  if (currentFn && !Obj2.instanceOf(Operation5.PersistentOperation, currentFn)) {
+    currentFn = void 0;
+  }
+  const currentFunctionName = currentFn ? currentFn.name ?? currentFn.id : void 0;
+  const shouldChangeFunction = yield* Option6.match(functionIdOption, {
+    onNone: () => Prompt5.confirm({
+      message: `Change the function${currentFunctionName ? ` (current: ${currentFunctionName})` : ""}?`,
+      initial: false
+    }).pipe(Prompt5.run),
+    onSome: () => Effect7.succeed(true)
+  });
+  if (shouldChangeFunction) {
+    const functionId = yield* Option6.match(functionIdOption, {
+      onNone: () => selectFunction(),
+      onSome: (id) => Effect7.succeed(id)
+    });
+    const functions = yield* Database7.runQuery(Filter6.type(Operation5.PersistentOperation));
+    const foundFn = functions.find((fn6) => fn6.id === functionId);
+    if (!foundFn || !Obj2.instanceOf(Operation5.PersistentOperation, foundFn)) {
+      return yield* Effect7.fail(new Error(`Function not found: ${functionId}`));
+    }
+    Obj2.update(trigger2, (trigger3) => {
+      trigger3.function = Ref5.make(foundFn);
+    });
+    currentFn = foundFn;
+  }
+  if (!currentFn) {
+    const functionId = trigger2.function?.dxn.asEchoDXN()?.echoId ?? "unknown";
+    return yield* Effect7.fail(new Error(`Invalid reference for ${functionId}`));
+  }
+  return currentFn;
+});
+var updateQueue = Effect7.fn(function* (trigger2, queueOption) {
+  const currentQueue = trigger2.spec?.kind === "queue" ? trigger2.spec.queue : void 0;
+  const currentQueueStr = currentQueue ? typeof currentQueue === "string" ? currentQueue : String(currentQueue) : void 0;
+  const shouldChangeQueue = yield* Option6.match(queueOption, {
+    onNone: () => Prompt5.confirm({
+      message: `Change the queue${currentQueueStr ? ` (current: ${currentQueueStr})` : ""}?`,
+      initial: false
+    }).pipe(Prompt5.run),
+    onSome: () => Effect7.succeed(true)
+  });
+  if (shouldChangeQueue) {
+    const queueDxn = yield* Option6.match(queueOption, {
+      onNone: () => selectQueue(),
+      onSome: (dxn) => Effect7.succeed(dxn.toString())
+    });
+    Obj2.update(trigger2, (trigger3) => {
+      if (trigger3.spec?.kind === "queue") {
+        trigger3.spec.queue = queueDxn;
+      }
+    });
+  }
+});
+var updateInput = Effect7.fn(function* (trigger2, fn6, inputOption) {
+  const currentInput = trigger2.input;
+  const currentInputStr = currentInput ? JSON.stringify(currentInput) : "none";
+  const shouldChangeInput = yield* Option6.match(inputOption, {
+    onNone: () => Effect7.gen(function* () {
+      yield* Console7.log(`Current input: ${currentInputStr}`);
+      return yield* Prompt5.confirm({
+        message: "Change input?",
+        initial: false
+      }).pipe(Prompt5.run);
+    }),
+    onSome: () => Effect7.succeed(true)
+  });
+  if (shouldChangeInput) {
+    const inputObj = yield* Option6.match(inputOption, {
+      onNone: () => promptForSchemaInput(fn6.inputSchema ? JsonSchema4.toEffectSchema(fn6.inputSchema) : void 0, currentInput),
+      onSome: (value2) => Effect7.succeed(value2)
+    });
+    Obj2.update(trigger2, (trigger3) => {
+      trigger3.input = inputObj;
+    });
+  }
+});
+var updateEnabled = Effect7.fn(function* (trigger2, idOption, enabled) {
+  const enabledValue = yield* Option6.match(idOption, {
+    onNone: () => Prompt5.confirm({
+      message: "Enable the trigger?",
+      initial: trigger2.enabled
+    }).pipe(Prompt5.run),
+    onSome: () => Effect7.succeed(enabled)
+  });
+  Obj2.update(trigger2, (trigger3) => {
+    trigger3.enabled = enabledValue;
+  });
+});
+
+// src/commands/trigger/update/subscription.ts
+import * as Command8 from "@effect/cli/Command";
+import * as Options8 from "@effect/cli/Options";
+import * as Prompt6 from "@effect/cli/Prompt";
+import * as Console8 from "effect/Console";
+import * as Effect8 from "effect/Effect";
+import * as Match2 from "effect/Match";
+import * as Option7 from "effect/Option";
+import { CommandConfig as CommandConfig7 } from "@dxos/cli-util";
+import { flushAndSync as flushAndSync5, print as print6, spaceLayer as spaceLayer7, withTypes as withTypes6 } from "@dxos/cli-util";
+import { Common as Common7 } from "@dxos/cli-util";
+import { Operation as Operation6, Trigger as Trigger8 } from "@dxos/compute";
+import { DXN as DXN4, Database as Database8, Filter as Filter7, JsonSchema as JsonSchema5, Obj as Obj3, Query as Query4, Ref as Ref6 } from "@dxos/echo";
+var subscription2 = Command8.make("subscription", {
+  spaceId: Common7.spaceId.pipe(Options8.optional),
+  id: TriggerId.pipe(Options8.optional),
+  enabled: Enabled,
+  functionId: Common7.functionId.pipe(Options8.optional),
+  typename: Typename.pipe(Options8.optional),
+  deep: Deep.pipe(Options8.optional),
+  delay: Delay.pipe(Options8.optional),
+  input: Input.pipe(Options8.optional)
+}, (options) => Effect8.gen(function* () {
+  const { json } = yield* CommandConfig7;
+  const triggerId = yield* Option7.match(options.id, {
+    onNone: () => selectTrigger("subscription"),
+    onSome: (id) => Effect8.succeed(id)
+  });
+  const dxn = DXN4.fromLocalObjectId(triggerId);
+  const trigger2 = yield* Database8.resolve(dxn, Trigger8.Trigger);
+  if (trigger2.spec?.kind !== "subscription") {
+    return yield* Effect8.fail(new Error(`Invalid trigger type: ${trigger2.spec?.kind}`));
+  }
+  const currentFn = yield* updateFunction2(trigger2, options.functionId);
+  yield* updateSpec(trigger2, options.typename, options.deep, options.delay);
+  yield* updateInput2(trigger2, currentFn, options.input);
+  yield* updateEnabled2(trigger2, options.id, options.enabled);
+  if (json) {
+    yield* Console8.log(JSON.stringify(trigger2, null, 2));
+  } else {
+    yield* Console8.log(print6(yield* printTrigger(trigger2)));
+  }
+  yield* flushAndSync5({
+    indexes: true
+  });
+})).pipe(Command8.withDescription("Update a subscription trigger."), Command8.provide(({ spaceId }) => spaceLayer7(spaceId, true)), Command8.provideEffectDiscard(() => withTypes6(Operation6.PersistentOperation, Trigger8.Trigger)));
+var extractCurrentTypename = (spec) => {
+  if (!spec?.query?.ast) {
+    return Option7.none();
+  }
+  return Match2.value(spec.query.ast).pipe(Match2.withReturnType(), Match2.when({
+    type: "select"
+  }, (q) => Match2.value(q.filter).pipe(Match2.withReturnType(), Match2.when({
+    type: "object"
+  }, (f) => Option7.fromNullable(f.typename).pipe(Option7.flatMap((dxn) => Option7.fromNullable(DXN4.tryParse(dxn))), Option7.flatMap((dxn) => Option7.fromNullable(dxn.asTypeDXN()?.type)))), Match2.orElse(() => Option7.none()))), Match2.orElse(() => Option7.none()));
+};
+var updateFunction2 = Effect8.fn(function* (trigger2, functionIdOption) {
+  let currentFn = trigger2.function ? yield* Database8.load(trigger2.function) : void 0;
+  if (currentFn && !Obj3.instanceOf(Operation6.PersistentOperation, currentFn)) {
+    currentFn = void 0;
+  }
+  const currentFunctionName = currentFn ? currentFn.name ?? currentFn.id : void 0;
+  const shouldChangeFunction = yield* Option7.match(functionIdOption, {
+    onNone: () => Prompt6.confirm({
+      message: `Change the function${currentFunctionName ? ` (current: ${currentFunctionName})` : ""}?`,
+      initial: false
+    }).pipe(Prompt6.run),
+    onSome: () => Effect8.succeed(true)
+  });
+  if (shouldChangeFunction) {
+    const functionId = yield* Option7.match(functionIdOption, {
+      onNone: () => selectFunction(),
+      onSome: (id) => Effect8.succeed(id)
+    });
+    const functions = yield* Database8.runQuery(Filter7.type(Operation6.PersistentOperation));
+    const foundFn = functions.find((fn6) => fn6.id === functionId);
+    if (!foundFn || !Obj3.instanceOf(Operation6.PersistentOperation, foundFn)) {
+      return yield* Effect8.fail(new Error(`Function not found: ${functionId}`));
+    }
+    Obj3.update(trigger2, (trigger3) => {
+      trigger3.function = Ref6.make(foundFn);
+    });
+    currentFn = foundFn;
+  }
+  if (!currentFn) {
+    const functionId = trigger2.function?.dxn.asEchoDXN()?.echoId ?? "unknown";
+    return yield* Effect8.fail(new Error(`Invalid reference for ${functionId}`));
+  }
+  return currentFn;
+});
+var updateSpec = Effect8.fn(function* (trigger2, typenameOption, deepOption, delayOption) {
+  const currentSpec = trigger2.spec?.kind === "subscription" ? trigger2.spec : void 0;
+  const currentTypename = extractCurrentTypename(currentSpec);
+  const currentTypenameStr = Option7.getOrUndefined(currentTypename);
+  const currentDeep = currentSpec?.options?.deep;
+  const currentDelay = currentSpec?.options?.delay;
+  const specParts = [];
+  if (currentTypenameStr) {
+    specParts.push(`typename: ${currentTypenameStr}`);
+  }
+  if (currentDeep !== void 0) {
+    specParts.push(`deep: ${currentDeep}`);
+  }
+  if (currentDelay !== void 0) {
+    specParts.push(`delay: ${currentDelay}`);
+  }
+  const currentSpecStr = specParts.length > 0 ? specParts.join(", ") : "none";
+  const hasSpecOption = Option7.isSome(typenameOption) || Option7.isSome(deepOption) || Option7.isSome(delayOption);
+  const shouldChangeSpec = yield* hasSpecOption ? Effect8.succeed(true) : Prompt6.confirm({
+    message: `Change the trigger spec (current: ${currentSpecStr})?`,
+    initial: false
+  }).pipe(Prompt6.run);
+  if (shouldChangeSpec) {
+    const typename = yield* Option7.match(typenameOption, {
+      onNone: () => Prompt6.text({
+        message: `Enter type name${currentTypenameStr ? ` (current: ${currentTypenameStr})` : ""}:`
+      }).pipe(Prompt6.run),
+      onSome: (value2) => Effect8.succeed(value2)
+    });
+    const queryAst = Query4.select(Filter7.type(typename)).ast;
+    const deepOptionValue = yield* Option7.match(deepOption, {
+      onNone: () => Prompt6.confirm({
+        message: "Watch changes to nested properties (deep)?",
+        initial: currentSpec?.options?.deep ?? false
+      }).pipe(Prompt6.run, Effect8.map((value2) => value2 ? Option7.some(value2) : Option7.none())),
+      onSome: () => Effect8.succeed(Option7.some(true))
+    });
+    const delayOptionValue = yield* Option7.match(delayOption, {
+      onNone: () => Effect8.gen(function* () {
+        const currentDelay2 = currentSpec?.options?.delay;
+        const delayStr = yield* Prompt6.text({
+          message: `Debounce delay in milliseconds (optional, press Enter to skip)${currentDelay2 ? ` (current: ${currentDelay2})` : ""}:`
+        }).pipe(Prompt6.run);
+        return delayStr === "" ? Option7.none() : Option7.some(parseInt(delayStr, 10));
+      }),
+      onSome: (value2) => Effect8.succeed(Option7.some(value2))
+    });
+    const subscriptionOptions = {};
+    if (Option7.isSome(deepOptionValue)) {
+      subscriptionOptions.deep = deepOptionValue.value;
+    }
+    if (Option7.isSome(delayOptionValue)) {
+      subscriptionOptions.delay = delayOptionValue.value;
+    }
+    Obj3.update(trigger2, (trigger3) => {
+      const spec = trigger3.spec;
+      if (spec?.kind === "subscription") {
+        spec.query = {
+          ast: queryAst
+        };
+        spec.options = Object.keys(subscriptionOptions).length > 0 ? subscriptionOptions : void 0;
+      }
+    });
+  }
+});
+var updateInput2 = Effect8.fn(function* (trigger2, fn6, inputOption) {
+  const currentInput = trigger2.input;
+  const currentInputStr = currentInput ? JSON.stringify(currentInput) : "none";
+  const shouldChangeInput = yield* Option7.match(inputOption, {
+    onNone: () => Effect8.gen(function* () {
+      yield* Console8.log(`Current input: ${currentInputStr}`);
+      return yield* Prompt6.confirm({
+        message: "Change input?",
+        initial: false
+      }).pipe(Prompt6.run);
+    }),
+    onSome: () => Effect8.succeed(true)
+  });
+  if (shouldChangeInput) {
+    const inputObj = yield* Option7.match(inputOption, {
+      onNone: () => promptForSchemaInput(fn6.inputSchema ? JsonSchema5.toEffectSchema(fn6.inputSchema) : void 0, currentInput),
+      onSome: (value2) => Effect8.succeed(value2)
+    });
+    Obj3.update(trigger2, (trigger3) => {
+      trigger3.input = inputObj;
+    });
+  }
+});
+var updateEnabled2 = Effect8.fn(function* (trigger2, idOption, enabled) {
+  const enabledValue = yield* Option7.match(idOption, {
+    onNone: () => Prompt6.confirm({
+      message: "Enable the trigger?",
+      initial: trigger2.enabled
+    }).pipe(Prompt6.run),
+    onSome: () => Effect8.succeed(enabled)
+  });
+  Obj3.update(trigger2, (trigger3) => {
+    trigger3.enabled = enabledValue;
+  });
+});
+
+// src/commands/trigger/update/timer.ts
+import * as Command9 from "@effect/cli/Command";
+import * as Options9 from "@effect/cli/Options";
+import * as Prompt7 from "@effect/cli/Prompt";
+import * as Console9 from "effect/Console";
+import * as Effect9 from "effect/Effect";
+import * as Option8 from "effect/Option";
+import { CommandConfig as CommandConfig8 } from "@dxos/cli-util";
+import { flushAndSync as flushAndSync6, print as print7, spaceLayer as spaceLayer8, withTypes as withTypes7 } from "@dxos/cli-util";
+import { Common as Common8 } from "@dxos/cli-util";
+import { Operation as Operation7, Trigger as Trigger9 } from "@dxos/compute";
+import { DXN as DXN5, Database as Database9, Filter as Filter8, JsonSchema as JsonSchema6, Obj as Obj4, Ref as Ref7 } from "@dxos/echo";
+var timer2 = Command9.make("timer", {
+  spaceId: Common8.spaceId.pipe(Options9.optional),
+  id: TriggerId.pipe(Options9.optional),
+  enabled: Enabled,
+  functionId: Common8.functionId.pipe(Options9.optional),
+  cron: Cron.pipe(Options9.optional),
+  input: Input.pipe(Options9.optional)
+}, (options) => Effect9.gen(function* () {
+  const { json } = yield* CommandConfig8;
+  const triggerId = yield* Option8.match(options.id, {
+    onNone: () => selectTrigger("timer"),
+    onSome: (id) => Effect9.succeed(id)
+  });
+  const dxn = DXN5.fromLocalObjectId(triggerId);
+  const trigger2 = yield* Database9.resolve(dxn, Trigger9.Trigger);
+  if (!trigger2.spec || trigger2.spec?.kind !== "timer") {
+    return yield* Effect9.fail(new Error(`Invalid trigger type: ${trigger2.spec?.kind}`));
+  }
+  const currentFn = yield* updateFunction3(trigger2, options.functionId);
+  yield* updateCron(trigger2, options.cron);
+  yield* updateInput3(trigger2, currentFn, options.input);
+  yield* updateEnabled3(trigger2, options.id, options.enabled);
+  if (json) {
+    yield* Console9.log(JSON.stringify(trigger2, null, 2));
+  } else {
+    yield* Console9.log(print7(yield* printTrigger(trigger2)));
+  }
+  yield* flushAndSync6({
+    indexes: true
+  });
+})).pipe(Command9.withDescription("Update a timer trigger."), Command9.provide(({ spaceId }) => spaceLayer8(spaceId, true)), Command9.provideEffectDiscard(() => withTypes7(Operation7.PersistentOperation, Trigger9.Trigger)));
+var updateFunction3 = Effect9.fn(function* (trigger2, functionIdOption) {
+  let currentFn = trigger2.function ? yield* Database9.load(trigger2.function) : void 0;
+  if (currentFn && !Obj4.instanceOf(Operation7.PersistentOperation, currentFn)) {
+    currentFn = void 0;
+  }
+  const currentFunctionName = currentFn ? currentFn.name ?? currentFn.id : void 0;
+  const shouldChangeFunction = yield* Option8.match(functionIdOption, {
+    onNone: () => Prompt7.confirm({
+      message: `Change the function${currentFunctionName ? ` (current: ${currentFunctionName})` : ""}?`,
+      initial: false
+    }).pipe(Prompt7.run),
+    onSome: () => Effect9.succeed(true)
+  });
+  if (shouldChangeFunction) {
+    const functionId = yield* Option8.match(functionIdOption, {
+      onNone: () => selectFunction(),
+      onSome: (id) => Effect9.succeed(id)
+    });
+    const functions = yield* Database9.runQuery(Filter8.type(Operation7.PersistentOperation));
+    const foundFn = functions.find((fn6) => fn6.id === functionId);
+    if (!foundFn || !Obj4.instanceOf(Operation7.PersistentOperation, foundFn)) {
+      return yield* Effect9.fail(new Error(`Function not found: ${functionId}`));
+    }
+    Obj4.update(trigger2, (trigger3) => {
+      trigger3.function = Ref7.make(foundFn);
+    });
+    currentFn = foundFn;
+  }
+  if (!currentFn) {
+    const functionId = trigger2.function?.dxn.asEchoDXN()?.echoId ?? "unknown";
+    return yield* Effect9.fail(new Error(`Invalid reference for ${functionId}`));
+  }
+  return currentFn;
+});
+var updateCron = Effect9.fn(function* (trigger2, cronOption) {
+  const currentCron = trigger2.spec?.kind === "timer" ? trigger2.spec.cron : void 0;
+  const shouldChangeCron = yield* Option8.match(cronOption, {
+    onNone: () => Prompt7.confirm({
+      message: `Change the cron expression${currentCron ? ` (current: ${currentCron})` : ""}?`,
+      initial: false
+    }).pipe(Prompt7.run),
+    onSome: () => Effect9.succeed(true)
+  });
+  if (shouldChangeCron) {
+    const cron = yield* Option8.match(cronOption, {
+      onNone: () => Prompt7.text({
+        message: `Enter cron expression${currentCron ? ` (current: ${currentCron})` : ""}:`
+      }).pipe(Prompt7.run),
+      onSome: (value2) => Effect9.succeed(value2)
+    });
+    Obj4.update(trigger2, (trigger3) => {
+      if (trigger3.spec?.kind === "timer") {
+        trigger3.spec.cron = cron;
+      }
+    });
+  }
+});
+var updateInput3 = Effect9.fn(function* (trigger2, fn6, inputOption) {
+  const currentInput = trigger2.input;
+  const currentInputStr = currentInput ? JSON.stringify(currentInput) : "none";
+  const shouldChangeInput = yield* Option8.match(inputOption, {
+    onNone: () => Effect9.gen(function* () {
+      yield* Console9.log(`Current input: ${currentInputStr}`);
+      return yield* Prompt7.confirm({
+        message: "Change input?",
+        initial: false
+      }).pipe(Prompt7.run);
+    }),
+    onSome: () => Effect9.succeed(true)
+  });
+  if (shouldChangeInput) {
+    const inputObj = yield* Option8.match(inputOption, {
+      onNone: () => promptForSchemaInput(fn6.inputSchema ? JsonSchema6.toEffectSchema(fn6.inputSchema) : void 0, currentInput),
+      onSome: (value2) => Effect9.succeed(value2)
+    });
+    Obj4.update(trigger2, (trigger3) => {
+      trigger3.input = inputObj;
+    });
+  }
+});
+var updateEnabled3 = Effect9.fn(function* (trigger2, idOption, enabled) {
+  const enabledValue = yield* Option8.match(idOption, {
+    onNone: () => Prompt7.confirm({
+      message: "Enable the trigger?",
+      initial: trigger2.enabled
+    }).pipe(Prompt7.run),
+    onSome: () => Effect9.succeed(enabled)
+  });
+  Obj4.update(trigger2, (trigger3) => {
+    trigger3.enabled = enabledValue;
+  });
+});
+
+// src/commands/trigger/update/index.ts
+var update = Command10.make("update").pipe(Command10.withDescription("Update a trigger."), Command10.withSubcommands([
+  subscription2,
+  timer2,
+  queue2
+]));
+
+// src/commands/trigger/index.ts
+var trigger = Command11.make("trigger").pipe(Command11.withDescription("Manage EDGE triggers."), Command11.withSubcommands([
+  create,
+  list,
+  remove,
+  update
+]));
+
+// src/AutomationPlugin.node.ts
+var AutomationPlugin = Plugin.define(meta).pipe(AppPlugin.addAppGraphModule({
+  activate: AppGraphBuilder
+}), AppPlugin.addCommandModule({
+  commands: [
+    trigger
+  ]
+}), AppPlugin.addOperationHandlerModule({
+  activate: OperationHandler
+}), AppPlugin.addSchemaModule({
+  schema: [
+    Operation8.PersistentOperation,
+    Trigger10.Trigger,
+    Trace.Message
+  ]
+}), Plugin.addModule({
+  activatesOn: ClientEvents.ClientReady,
+  firesAfterActivation: [
+    AutomationEvents.ComputeRuntimeReady
+  ],
+  activate: ComputeRuntime
+}), Plugin.make);
+var AutomationPlugin_node_default = AutomationPlugin;
+export {
+  AutomationPlugin,
+  AutomationPlugin_node_default as default
+};
+//# sourceMappingURL=AutomationPlugin.node.mjs.map