@dxos/plugin-automation 0.6.14-main.1366248

package/dist/lib/node-esm/index.mjs

@@ -0,0 +1,1151 @@
+import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
+import {
+  PromptEditor
+} from "./chunk-FN6DOJZP.mjs";
+import {
+  AutomationAction,
+  ChainInputSchema,
+  ChainInputType,
+  ChainPromptType,
+  ChainType
+} from "./chunk-AAUSG7OA.mjs";
+import {
+  AUTOMATION_PLUGIN,
+  meta_default
+} from "./chunk-B35UD3D7.mjs";
+
+// packages/plugins/experimental/plugin-automation/src/AutomationPlugin.tsx
+import React6 from "react";
+import { parseMetadataResolverPlugin, resolvePlugin } from "@dxos/app-framework";
+import { FunctionDef, FunctionTrigger as FunctionTrigger2 } from "@dxos/functions/types";
+import { invariant as invariant2 } from "@dxos/invariant";
+import { parseClientPlugin } from "@dxos/plugin-client";
+import { createExtension, toSignal } from "@dxos/plugin-graph";
+import { getTypename, loadObjectReferences, parseId } from "@dxos/react-client/echo";
+
+// packages/plugins/experimental/plugin-automation/src/components/index.ts
+import { lazy } from "react";
+
+// packages/plugins/experimental/plugin-automation/src/components/AutomationPanel.tsx
+import React from "react";
+import { Button, Icon, Toolbar } from "@dxos/react-ui";
+var AutomationPanel = () => {
+  const handleCreate = () => {
+  };
+  return /* @__PURE__ */ React.createElement("div", {
+    className: "flex flex-col"
+  }, /* @__PURE__ */ React.createElement(Toolbar.Root, {
+    classNames: "p-2"
+  }, /* @__PURE__ */ React.createElement(Button, {
+    onClick: handleCreate
+  }, /* @__PURE__ */ React.createElement(Icon, {
+    icon: "ph--plus--regular"
+  }))));
+};
+
+// packages/plugins/experimental/plugin-automation/src/components/Chain.tsx
+import React2 from "react";
+import { getSpace } from "@dxos/react-client/echo";
+import { Select, useTranslation } from "@dxos/react-ui";
+import { nonNullable } from "@dxos/util";
+
+// packages/plugins/experimental/plugin-automation/src/presets.ts
+import { create } from "@dxos/echo-schema";
+var str = (...text) => text.filter((value) => value !== void 0 && value !== false).flat().join("\n");
+var chainPresets = [
+  {
+    id: "dxos.org/prompt/translate",
+    title: "Translate",
+    createPrompt: () => create(ChainPromptType, {
+      command: "say",
+      template: str(
+        // prettier-ignore
+        "Translate the following into {language}:",
+        "",
+        "---",
+        "",
+        "{input}"
+      ),
+      inputs: [
+        {
+          type: ChainInputType.VALUE,
+          name: "language",
+          value: "japanese"
+        },
+        {
+          type: ChainInputType.PASS_THROUGH,
+          name: "input"
+        }
+      ]
+    })
+  },
+  {
+    id: "dxos.org/prompt/chess",
+    title: "Chess",
+    createPrompt: () => create(ChainPromptType, {
+      command: "hint",
+      template: str(
+        // prettier-ignore
+        "You are a machine that is an expert chess player.",
+        "",
+        "The move history of the current game is: {history}",
+        "",
+        "Suggest the next move and very briefly explain your strategy in a couple of sentences."
+      ),
+      inputs: [
+        {
+          type: ChainInputType.CONTEXT,
+          name: "history",
+          value: "object.pgn"
+        }
+      ]
+    })
+  },
+  {
+    id: "dxos.org/prompt/mermaid",
+    title: "Mermaid",
+    createPrompt: () => create(ChainPromptType, {
+      command: "draw",
+      template: str(
+        // prettier-ignore
+        "Create a simplified mermaid graph representing the text below.",
+        "Do not explain anything.",
+        "",
+        "---",
+        "",
+        "{input}"
+      ),
+      inputs: [
+        {
+          type: ChainInputType.PASS_THROUGH,
+          name: "input"
+        }
+      ]
+    })
+  },
+  {
+    id: "dxos.org/prompt/list",
+    title: "List",
+    createPrompt: () => create(ChainPromptType, {
+      command: "list",
+      template: str(
+        // prettier-ignore
+        "You are a machine that only replies with valid, iterable RFC8259 compliant JSON in your responses.",
+        "Your entire response should be a single array of JSON objects.",
+        "",
+        "Your entire response should be a map where the key is the type and the value is a single array of JSON objects conforming to the following types:",
+        "",
+        "{schema}",
+        "",
+        "---",
+        "",
+        "{question}"
+      ),
+      inputs: [
+        {
+          type: ChainInputType.SCHEMA,
+          name: "schema",
+          value: "example.com/type/project"
+        },
+        {
+          type: ChainInputType.PASS_THROUGH,
+          name: "question"
+        }
+      ]
+    })
+  },
+  {
+    id: "dxos.org/prompt/base",
+    title: "RAG",
+    createPrompt: () => create(ChainPromptType, {
+      command: "rag",
+      template: str(
+        // prettier-ignore
+        "Very briefly answer the question based only on the following context and say if you don't know the answer.",
+        // 'answer the question using the following context as well as your training data:',
+        "",
+        "{context}",
+        "",
+        "---",
+        "",
+        "question: {question}"
+      ),
+      inputs: [
+        {
+          type: ChainInputType.RETRIEVER,
+          name: "context"
+        },
+        {
+          type: ChainInputType.CONTEXT,
+          name: "question",
+          value: "object.text"
+        }
+      ]
+    })
+  },
+  {
+    id: "dxos.org/prompt/lookup",
+    title: "Lookup",
+    createPrompt: () => create(ChainPromptType, {
+      command: "lookup",
+      template: str(
+        // prettier-ignore
+        "Lookup and very briefly summarize the following topic in one or two sentences:",
+        "",
+        "---",
+        "",
+        "{input}"
+      ),
+      inputs: [
+        {
+          type: ChainInputType.CONTEXT,
+          name: "input",
+          value: "text"
+        }
+      ]
+    })
+  },
+  {
+    id: "dxos.org/prompt/extract",
+    title: "Extract",
+    createPrompt: () => create(ChainPromptType, {
+      command: "extract",
+      template: str(
+        // prettier-ignore
+        "List all people and companies mentioned in the text below.",
+        "",
+        "You are a machine that only replies with valid, iterable RFC8259 compliant JSON in your responses.",
+        "Your entire response should be a map where the key is the type and the value is a single array of JSON objects conforming to the following types:",
+        "",
+        "{contact}",
+        "{company}",
+        "",
+        "---",
+        "",
+        "{input}"
+      ),
+      inputs: [
+        {
+          type: ChainInputType.SCHEMA,
+          name: "contact",
+          value: "example.com/type/contact"
+        },
+        {
+          type: ChainInputType.SCHEMA,
+          name: "company",
+          value: "example.com/type/organization"
+        },
+        {
+          type: ChainInputType.CONTEXT,
+          name: "input",
+          value: "text"
+        }
+      ]
+    })
+  },
+  {
+    id: "dxos.org/prompt/discord",
+    title: "Summarize",
+    createPrompt: () => create(ChainPromptType, {
+      command: "summarize",
+      template: str(
+        // prettier-ignore
+        "Summarize what the team is working on and format it as a markdown table without any explanation.",
+        "",
+        "---",
+        "",
+        "{context}"
+      ),
+      inputs: [
+        {
+          type: ChainInputType.RESOLVER,
+          name: "context",
+          value: "discord.messages.recent"
+        }
+      ]
+    })
+  }
+];
+
+// packages/plugins/experimental/plugin-automation/src/components/Chain.tsx
+var Chain = ({ chain }) => {
+  const space = getSpace(chain);
+  if (!space) {
+    return null;
+  }
+  const handleSelectPreset = (preset) => {
+    chain.name = preset.title;
+    chain.prompts?.filter(nonNullable).forEach((prompt) => space.db.remove(prompt));
+    chain.prompts = [
+      preset.createPrompt()
+    ];
+  };
+  return /* @__PURE__ */ React2.createElement("div", {
+    className: "flex flex-col my-2 gap-4"
+  }, chain.prompts?.filter(nonNullable).map((prompt, i) => /* @__PURE__ */ React2.createElement(PromptEditor, {
+    key: i,
+    prompt
+  })), /* @__PURE__ */ React2.createElement("div", {
+    className: "p-2"
+  }, /* @__PURE__ */ React2.createElement(ChainPresets, {
+    presets: chainPresets,
+    onSelect: handleSelectPreset
+  })));
+};
+var ChainPresets = ({ presets, onSelect }) => {
+  const { t } = useTranslation(AUTOMATION_PLUGIN);
+  return /* @__PURE__ */ React2.createElement(Select.Root, {
+    onValueChange: (value) => {
+      onSelect(presets.find(({ id }) => id === value));
+    }
+  }, /* @__PURE__ */ React2.createElement(Select.TriggerButton, {
+    classNames: "w-full",
+    placeholder: t("select preset template placeholder")
+  }), /* @__PURE__ */ React2.createElement(Select.Portal, null, /* @__PURE__ */ React2.createElement(Select.Content, null, /* @__PURE__ */ React2.createElement(Select.Viewport, null, presets.map(({ id, title }) => /* @__PURE__ */ React2.createElement(Select.Option, {
+    key: id,
+    value: id
+  }, title))))));
+};
+
+// packages/plugins/experimental/plugin-automation/src/components/TriggerEditor/TriggerEditor.tsx
+import React5, { useEffect, useMemo, useState } from "react";
+import { Mutex } from "@dxos/async";
+import { Context } from "@dxos/context";
+import { createSubscriptionTrigger, createWebsocketTrigger } from "@dxos/functions";
+import { FunctionTrigger } from "@dxos/functions/types";
+import { log as log3 } from "@dxos/log";
+import { ScriptType } from "@dxos/plugin-script/types";
+import { useClient } from "@dxos/react-client";
+import { Filter as Filter2, useQuery } from "@dxos/react-client/echo";
+import { Input as Input3, Select as Select2 } from "@dxos/react-ui";
+import { distinctBy } from "@dxos/util";
+
+// packages/plugins/experimental/plugin-automation/src/components/TriggerEditor/Form.tsx
+import React3 from "react";
+import { Input } from "@dxos/react-ui";
+var InputRow = ({ label, children }) => /* @__PURE__ */ React3.createElement(Input.Root, null, /* @__PURE__ */ React3.createElement("tr", null, /* @__PURE__ */ React3.createElement("td", {
+  className: "w-[80px] px-2 text-right align-top pt-3 overflow-hidden"
+}, /* @__PURE__ */ React3.createElement(Input.Label, {
+  classNames: "truncate text-xs"
+}, label)), /* @__PURE__ */ React3.createElement("td", {
+  className: "p-1 pr-2"
+}, children)));
+
+// packages/plugins/experimental/plugin-automation/src/components/TriggerEditor/invokation-handler.ts
+import { sleep } from "@dxos/async";
+import { getObjectCore } from "@dxos/echo-db";
+import { invariant } from "@dxos/invariant";
+import { DXN, LOCAL_SPACE_TAG } from "@dxos/keys";
+import { log as log2 } from "@dxos/log";
+import { FunctionType } from "@dxos/plugin-script";
+
+// packages/plugins/experimental/plugin-automation/src/components/TriggerEditor/email.ts
+import { findObjectWithForeignKey } from "@dxos/echo-db";
+import { create as create2, foreignKey } from "@dxos/echo-schema";
+import { log } from "@dxos/log";
+import { MailboxType } from "@dxos/plugin-inbox/types";
+import { MessageType } from "@dxos/plugin-space/types";
+import { Filter } from "@dxos/react-client/echo";
+var __dxlog_file = "/home/runner/work/dxos/dxos/packages/plugins/experimental/plugin-automation/src/components/TriggerEditor/email.ts";
+var SOURCE_ID = "hub.dxos.network/api/mailbox";
+var handleEmail = async (space, data) => {
+  const { messages } = data;
+  const { objects: mailboxes } = await space.db.query(Filter.schema(MailboxType)).run();
+  const mailbox = mailboxes[0] ?? space.db.add(create2(MailboxType, {
+    messages: []
+  }));
+  log.info("messages", {
+    count: messages.length,
+    existingMailbox: mailboxes.length > 0
+  }, {
+    F: __dxlog_file,
+    L: 21,
+    S: void 0,
+    C: (f, a) => f(...a)
+  });
+  const { objects } = await space.db.query(Filter.schema(MessageType)).run();
+  for (const message of messages) {
+    let object = findObjectWithForeignKey(objects, {
+      source: SOURCE_ID,
+      id: String(message.id)
+    });
+    if (!object) {
+      object = space.db.add(create2(MessageType, {
+        sender: {
+          email: message.from
+        },
+        timestamp: new Date(message.created).toISOString(),
+        text: message.body,
+        properties: {
+          subject: message.subject,
+          to: [
+            {
+              email: message.to
+            }
+          ]
+        }
+      }, {
+        keys: [
+          foreignKey(SOURCE_ID, String(message.id))
+        ]
+      }));
+      mailbox.messages?.push(object);
+    }
+  }
+  return 200;
+};
+
+// packages/plugins/experimental/plugin-automation/src/components/TriggerEditor/invokation-handler.ts
+var __dxlog_file2 = "/home/runner/work/dxos/dxos/packages/plugins/experimental/plugin-automation/src/components/TriggerEditor/invokation-handler.ts";
+var MAX_RETRIES = 3;
+var RETRY_DELAY = 1e3;
+var callFunction = async (funcUrl, trigger, data) => {
+  const body = {
+    event: "trigger",
+    trigger,
+    data
+  };
+  let retryCount = 0;
+  while (retryCount < MAX_RETRIES) {
+    log2.info("exec", {
+      funcUrl,
+      body,
+      retryCount
+    }, {
+      F: __dxlog_file2,
+      L: 26,
+      S: void 0,
+      C: (f, a) => f(...a)
+    });
+    const response = await fetch(funcUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(body)
+    });
+    const data2 = await response.text();
+    log2.info("response", {
+      status: response.status,
+      body: data2
+    }, {
+      F: __dxlog_file2,
+      L: 36,
+      S: void 0,
+      C: (f, a) => f(...a)
+    });
+    if (response.status === 409) {
+      retryCount++;
+      await sleep(RETRY_DELAY * Math.min(retryCount, 2));
+      continue;
+    }
+    return {
+      status: response.status,
+      data: data2
+    };
+  }
+  return {
+    status: 500
+  };
+};
+var invokeFunction = async (client, space, trigger, data) => {
+  try {
+    if (trigger.spec.type === "websocket") {
+      return handleEmail(space, data.data);
+    }
+    const script = await space.crud.query({
+      id: trigger.function
+    }).first();
+    const { objects: functions } = await space.crud.query({
+      __typename: FunctionType.typename
+    }).run();
+    const func = functions.find((fn) => referenceEquals(fn.source, trigger.function));
+    const funcSlug = func?.__meta.keys.find((key) => key.source === USERFUNCTIONS_META_KEY)?.id;
+    if (!funcSlug) {
+      log2.warn("function not deployed", {
+        scriptId: script.id,
+        name: script.name
+      }, {
+        F: __dxlog_file2,
+        L: 59,
+        S: void 0,
+        C: (f, a) => f(...a)
+      });
+      return 404;
+    }
+    const funcUrl = getFunctionUrl(client.config, funcSlug, space.id);
+    const triggerData = {
+      ...getObjectCore(trigger).toPlainObject(),
+      // TODO: Remove when functions can query by DXN.
+      promptId: trigger.meta?.prompt?.id
+    };
+    return (await callFunction(funcUrl, triggerData, data)).status;
+  } catch (err) {
+    return 400;
+  }
+};
+var USERFUNCTIONS_META_KEY = "dxos.org/service/function";
+var getFunctionUrl = (config, slug, spaceId) => {
+  const baseUrl = new URL("functions/", config.values.runtime?.services?.edge?.url);
+  const relativeUrl = slug.replace(/^\//, "");
+  const url = new URL(`./${relativeUrl}`, baseUrl.toString());
+  spaceId && url.searchParams.set("spaceId", spaceId);
+  url.protocol = "https";
+  return url.toString();
+};
+var referenceEquals = (a, b) => {
+  const aDXN = toDXN(a);
+  const bDXN = toDXN(b);
+  return aDXN.toString() === bDXN.toString();
+};
+var toDXN = (ref) => {
+  if (typeof ref === "string") {
+    if (ref.startsWith("dxn:")) {
+      return DXN.parse(ref);
+    } else {
+      return new DXN(DXN.kind.ECHO, [
+        LOCAL_SPACE_TAG,
+        ref
+      ]);
+    }
+  }
+  invariant(typeof ref["/"] === "string", void 0, {
+    F: __dxlog_file2,
+    L: 108,
+    S: void 0,
+    A: [
+      "typeof ref['/'] === 'string'",
+      ""
+    ]
+  });
+  return DXN.parse(ref["/"]);
+};
+
+// packages/plugins/experimental/plugin-automation/src/components/TriggerEditor/meta.tsx
+import React4 from "react";
+import { create as create3, getMeta as getEchoMeta } from "@dxos/echo-schema";
+import { GameType } from "@dxos/plugin-chess/types";
+import { FileType } from "@dxos/plugin-ipfs/types";
+import { DocumentType } from "@dxos/plugin-markdown";
+import { DiagramType } from "@dxos/plugin-sketch/types";
+import { CollectionType, MessageType as MessageType2 } from "@dxos/plugin-space";
+import { Input as Input2 } from "@dxos/react-ui";
+import { safeParseInt } from "@dxos/util";
+var stateInitialValues = {
+  schemas: [
+    // TODO(burdon): Get all schema from API.
+    DocumentType,
+    FileType,
+    GameType,
+    MessageType2,
+    DiagramType,
+    CollectionType
+  ],
+  selectedSchema: {}
+};
+var state = create3(stateInitialValues);
+var USERFUNCTIONS_PRESET_META_KEY = "dxos.org/service/function-preset";
+var getFunctionMetaExtension = (trigger, script) => {
+  if (script) {
+    const meta = getEchoMeta(script).keys.find((key) => key.source === USERFUNCTIONS_PRESET_META_KEY);
+    const extension = meta && metaExtensions[meta.id];
+    if (extension) {
+      return extension;
+    }
+  }
+  return trigger?.function ? metaExtensions[trigger.function] : metaExtensions["dxos.org/function/gpt"];
+};
+var DefaultMetaProps = ({ meta }) => {
+  return /* @__PURE__ */ React4.createElement(React4.Fragment, null);
+};
+var ChessMetaProps = ({ meta }) => {
+  if (!meta) {
+    return null;
+  }
+  return /* @__PURE__ */ React4.createElement(React4.Fragment, null, /* @__PURE__ */ React4.createElement(InputRow, {
+    label: "Level"
+  }, /* @__PURE__ */ React4.createElement(Input2.TextInput, {
+    type: "number",
+    value: meta.level ?? 1,
+    onChange: (event) => meta.level = safeParseInt(event.target.value),
+    placeholder: "Engine strength."
+  })));
+};
+var EmailWorkerMetaProps = ({ meta }) => {
+  if (!meta) {
+    return null;
+  }
+  return /* @__PURE__ */ React4.createElement(React4.Fragment, null, /* @__PURE__ */ React4.createElement(InputRow, {
+    label: "Account"
+  }, /* @__PURE__ */ React4.createElement(Input2.TextInput, {
+    value: meta.account ?? "",
+    onChange: (event) => meta.account = event.target.value,
+    placeholder: "https://"
+  })));
+};
+var ChainPromptMetaProps = ({ meta, triggerId }) => {
+  const schema = triggerId ? state.selectedSchema[triggerId] : void 0;
+  if (!meta) {
+    return null;
+  }
+  return /* @__PURE__ */ React4.createElement(React4.Fragment, null, /* @__PURE__ */ React4.createElement(InputRow, {
+    label: "Model"
+  }, /* @__PURE__ */ React4.createElement(Input2.TextInput, {
+    value: meta.model ?? "",
+    onChange: (event) => meta.model = event.target.value,
+    placeholder: "llama2"
+  })), /* @__PURE__ */ React4.createElement(InputRow, {
+    label: "Presets"
+  }, /* @__PURE__ */ React4.createElement(ChainPresets, {
+    presets: chainPresets,
+    onSelect: (preset) => {
+      meta.prompt = preset.createPrompt();
+    }
+  })), meta.prompt && /* @__PURE__ */ React4.createElement(InputRow, {
+    label: "Prompt"
+  }, /* @__PURE__ */ React4.createElement(PromptEditor, {
+    prompt: meta.prompt,
+    schema
+  })));
+};
+var EmbeddingMetaProps = ({ meta }) => {
+  if (!meta) {
+    return null;
+  }
+  return /* @__PURE__ */ React4.createElement(React4.Fragment, null, /* @__PURE__ */ React4.createElement(InputRow, {
+    label: "Model"
+  }, /* @__PURE__ */ React4.createElement(Input2.TextInput, {
+    value: meta.model ?? "",
+    onChange: (event) => meta.model = event.target.value,
+    placeholder: "llama2"
+  })));
+};
+var metaExtensions = {
+  __DEFAULT__: {
+    initialValue: () => ({}),
+    component: DefaultMetaProps
+  },
+  "dxos.org/function/chess": {
+    initialValue: () => ({
+      level: 2
+    }),
+    component: ChessMetaProps
+  },
+  "dxos.org/function/email-worker": {
+    initialValue: () => ({
+      account: "hello@dxos.network"
+    }),
+    component: EmailWorkerMetaProps
+  },
+  "dxos.org/function/gpt": {
+    initialValue: () => ({
+      model: "llama2"
+    }),
+    component: ChainPromptMetaProps
+  },
+  "dxos.org/function/embedding": {
+    initialValue: () => ({
+      model: "llama2"
+    }),
+    component: EmbeddingMetaProps
+  }
+};
+
+// packages/plugins/experimental/plugin-automation/src/components/TriggerEditor/TriggerEditor.tsx
+var __dxlog_file3 = "/home/runner/work/dxos/dxos/packages/plugins/experimental/plugin-automation/src/components/TriggerEditor/TriggerEditor.tsx";
+var triggerTypes = [
+  "subscription",
+  "timer",
+  "webhook",
+  "websocket"
+];
+var registerTriggersMutex = new Mutex();
+var TriggerEditor = ({ space, trigger }) => {
+  const client = useClient();
+  const scripts = useQuery(space, Filter2.schema(ScriptType));
+  const script = useMemo(() => scripts.find((script2) => script2.id === trigger.function), [
+    trigger.function,
+    scripts
+  ]);
+  const [registry] = useState(/* @__PURE__ */ new Map());
+  const triggers = useQuery(space, Filter2.schema(FunctionTrigger));
+  useEffect(() => {
+    setTimeout(async () => {
+      await registerTriggersMutex.executeSynchronized(async () => {
+        const deprecated = new Set(Array.from(registry.keys()));
+        log3.info("triggers", {
+          deprecated,
+          all: triggers.map((t) => t.id),
+          enabled: triggers.filter((t) => t.enabled).map((t) => t.id)
+        }, {
+          F: __dxlog_file3,
+          L: 47,
+          S: void 0,
+          C: (f, a) => f(...a)
+        });
+        for (const trigger2 of triggers) {
+          if (trigger2.enabled) {
+            if (registry.has(trigger2.id)) {
+              deprecated.delete(trigger2.id);
+              continue;
+            }
+            log3.info("activating trigger", trigger2.id, {
+              F: __dxlog_file3,
+              L: 59,
+              S: void 0,
+              C: (f, a) => f(...a)
+            });
+            const ctx = new Context(void 0, {
+              F: __dxlog_file3,
+              L: 61
+            });
+            registry.set(trigger2.id, ctx);
+            const triggerSpec = trigger2.spec;
+            let triggerFactory;
+            if (triggerSpec.type === "subscription") {
+              triggerFactory = createSubscriptionTrigger;
+            } else if (triggerSpec.type === "websocket") {
+              triggerFactory = createWebsocketTrigger;
+            } else {
+              log3.info("unsupported trigger", {
+                type: triggerSpec.type
+              }, {
+                F: __dxlog_file3,
+                L: 71,
+                S: void 0,
+                C: (f, a) => f(...a)
+              });
+              continue;
+            }
+            await triggerFactory(ctx, space, trigger2.spec, (data) => {
+              return invokeFunction(client, space, trigger2, data);
+            });
+          }
+        }
+        for (const id of deprecated) {
+          const ctx = registry.get(id);
+          if (ctx) {
+            await ctx.dispose();
+            registry.delete(id);
+          }
+        }
+      });
+    });
+  }, [
+    JSON.stringify(triggers)
+  ]);
+  useEffect(() => {
+    return () => {
+      for (const ctx of registry.values()) {
+        void ctx.dispose();
+      }
+    };
+  }, []);
+  useEffect(() => {
+    void space.db.schemaRegistry.query().then((schemas) => {
+      state.schemas = distinctBy([
+        ...state.schemas,
+        ...schemas
+      ], (schema) => schema.typename).sort((a, b) => a.typename < b.typename ? -1 : 1);
+    }).catch(() => {
+    });
+  }, [
+    space
+  ]);
+  useEffect(() => {
+    const spec = trigger.spec;
+    if (spec.type === "subscription") {
+      if (spec.filter && spec.filter.length > 0) {
+        const type = spec.filter[0].type;
+        const foundSchema = state.schemas.find((schema) => schema.typename === type);
+        if (foundSchema) {
+          state.selectedSchema[trigger.id] = foundSchema;
+        }
+      }
+    }
+  }, [
+    JSON.stringify(trigger.spec),
+    state.schemas
+  ]);
+  useEffect(() => {
+    if (!trigger.meta) {
+      const extension = getFunctionMetaExtension(trigger, script);
+      trigger.meta = extension?.initialValue?.();
+    }
+  }, [
+    trigger.function,
+    trigger.meta
+  ]);
+  const handleSelectFunction = (value) => {
+    const match = scripts.find((fn) => fn.id === value);
+    if (match) {
+      trigger.function = match.id;
+    }
+  };
+  const handleSelectTriggerType = (triggerType) => {
+    switch (triggerType) {
+      case "subscription": {
+        trigger.spec = {
+          type: "subscription",
+          filter: []
+        };
+        break;
+      }
+      case "timer": {
+        trigger.spec = {
+          type: "timer",
+          cron: "0 0 * * *"
+        };
+        break;
+      }
+      case "webhook": {
+        trigger.spec = {
+          type: "webhook",
+          method: "GET"
+        };
+        break;
+      }
+      case "websocket": {
+        trigger.spec = {
+          type: "websocket",
+          url: "",
+          init: {
+            type: "sync"
+          }
+        };
+        break;
+      }
+    }
+  };
+  const TriggerMeta = getFunctionMetaExtension(trigger, script)?.component;
+  return /* @__PURE__ */ React5.createElement("div", {
+    className: "flex flex-col py-1"
+  }, /* @__PURE__ */ React5.createElement("table", {
+    className: "is-full table-fixed"
+  }, /* @__PURE__ */ React5.createElement("tbody", null, /* @__PURE__ */ React5.createElement(InputRow, {
+    label: "Function"
+  }, /* @__PURE__ */ React5.createElement(Select2.Root, {
+    value: script?.id,
+    onValueChange: handleSelectFunction
+  }, /* @__PURE__ */ React5.createElement(Select2.TriggerButton, {
+    placeholder: "Select function"
+  }), /* @__PURE__ */ React5.createElement(Select2.Portal, null, /* @__PURE__ */ React5.createElement(Select2.Content, null, /* @__PURE__ */ React5.createElement(Select2.Viewport, null, scripts.map(({ id, name }) => /* @__PURE__ */ React5.createElement(Select2.Option, {
+    key: id,
+    value: id
+  }, name ?? "Unnamed"))))))), script?.description?.length && /* @__PURE__ */ React5.createElement(InputRow, null, /* @__PURE__ */ React5.createElement("div", {
+    className: "px-2"
+  }, /* @__PURE__ */ React5.createElement("p", {
+    className: "text-sm text-description"
+  }, script?.description?.length))), /* @__PURE__ */ React5.createElement(InputRow, {
+    label: "Type"
+  }, /* @__PURE__ */ React5.createElement(Select2.Root, {
+    value: trigger.spec?.type,
+    onValueChange: handleSelectTriggerType
+  }, /* @__PURE__ */ React5.createElement(Select2.TriggerButton, {
+    placeholder: "Select trigger"
+  }), /* @__PURE__ */ React5.createElement(Select2.Portal, null, /* @__PURE__ */ React5.createElement(Select2.Content, null, /* @__PURE__ */ React5.createElement(Select2.Viewport, null, triggerTypes.map((trigger2) => /* @__PURE__ */ React5.createElement(Select2.Option, {
+    key: trigger2,
+    value: trigger2
+  }, trigger2)))))))), /* @__PURE__ */ React5.createElement("tbody", null, trigger.spec && /* @__PURE__ */ React5.createElement(TriggerSpec, {
+    space,
+    spec: trigger.spec
+  }), /* @__PURE__ */ React5.createElement(InputRow, {
+    label: "Enabled"
+  }, /* @__PURE__ */ React5.createElement("div", {
+    className: "flex items-center h-8"
+  }, /* @__PURE__ */ React5.createElement(Input3.Switch, {
+    checked: trigger.enabled,
+    onCheckedChange: (checked) => trigger.enabled = !!checked
+  })))), TriggerMeta && /* @__PURE__ */ React5.createElement("tbody", null, /* @__PURE__ */ React5.createElement("tr", null, /* @__PURE__ */ React5.createElement("td", null), /* @__PURE__ */ React5.createElement("td", {
+    className: "py-2"
+  }, /* @__PURE__ */ React5.createElement("div", {
+    className: "border-b border-separator"
+  }))), /* @__PURE__ */ React5.createElement(TriggerMeta, {
+    meta: trigger.meta
+  }))));
+};
+var TriggerSpecSubscription = ({ spec }) => {
+  if (!spec.filter) {
+    return null;
+  }
+  const handleSelectSchema = (typename) => {
+    spec.filter = [
+      {
+        type: typename
+      }
+    ];
+  };
+  return /* @__PURE__ */ React5.createElement(React5.Fragment, null, /* @__PURE__ */ React5.createElement(InputRow, {
+    label: "Filter"
+  }, /* @__PURE__ */ React5.createElement(Select2.Root, {
+    value: spec.filter.length > 0 ? spec.filter[0].type : void 0,
+    onValueChange: handleSelectSchema
+  }, /* @__PURE__ */ React5.createElement(Select2.TriggerButton, {
+    classNames: "w-full",
+    placeholder: "Select type"
+  }), /* @__PURE__ */ React5.createElement(Select2.Portal, null, /* @__PURE__ */ React5.createElement(Select2.Content, null, /* @__PURE__ */ React5.createElement(Select2.Viewport, null, state.schemas.map(({ typename }) => /* @__PURE__ */ React5.createElement(Select2.Option, {
+    key: typename,
+    value: typename
+  }, typename))))))));
+};
+var TriggerSpecTimer = ({ spec }) => /* @__PURE__ */ React5.createElement(React5.Fragment, null, /* @__PURE__ */ React5.createElement(InputRow, {
+  label: "Cron"
+}, /* @__PURE__ */ React5.createElement(Input3.TextInput, {
+  value: spec.cron,
+  onChange: (event) => spec.cron = event.target.value
+})));
+var methods = [
+  "GET",
+  "POST"
+];
+var TriggerSpecWebhook = ({ spec }) => /* @__PURE__ */ React5.createElement(React5.Fragment, null, /* @__PURE__ */ React5.createElement(InputRow, {
+  label: "Method"
+}, /* @__PURE__ */ React5.createElement(Select2.Root, {
+  value: spec.method,
+  onValueChange: (value) => spec.method = value
+}, /* @__PURE__ */ React5.createElement(Select2.TriggerButton, {
+  placeholder: "type"
+}), /* @__PURE__ */ React5.createElement(Select2.Portal, null, /* @__PURE__ */ React5.createElement(Select2.Content, null, /* @__PURE__ */ React5.createElement(Select2.Viewport, null, methods.map((method) => /* @__PURE__ */ React5.createElement(Select2.Option, {
+  key: method,
+  value: method
+}, method))))))));
+var TriggerSpecWebsocket = ({ spec }) => {
+  const handleChangeInit = (event) => {
+    try {
+      spec.init = JSON.parse(event.target.value);
+    } catch (err) {
+    }
+  };
+  return /* @__PURE__ */ React5.createElement(React5.Fragment, null, /* @__PURE__ */ React5.createElement(InputRow, {
+    label: "Endpoint"
+  }, /* @__PURE__ */ React5.createElement(Input3.TextInput, {
+    value: spec.url,
+    onChange: (event) => spec.url = event.target.value,
+    placeholder: "https://"
+  })), /* @__PURE__ */ React5.createElement(InputRow, {
+    label: "Init"
+  }, /* @__PURE__ */ React5.createElement(Input3.TextInput, {
+    value: JSON.stringify(spec.init),
+    onChange: handleChangeInit,
+    placeholder: "Initial message."
+  })));
+};
+var triggerRenderers = {
+  subscription: TriggerSpecSubscription,
+  timer: TriggerSpecTimer,
+  webhook: TriggerSpecWebhook,
+  websocket: TriggerSpecWebsocket
+};
+var TriggerSpec = ({ space, spec }) => {
+  const Component = triggerRenderers[spec.type];
+  return Component ? /* @__PURE__ */ React5.createElement(Component, {
+    space,
+    spec
+  }) : null;
+};
+
+// packages/plugins/experimental/plugin-automation/src/components/index.ts
+var PromptContainer = lazy(() => import("./PromptContainer-5OK4GWIR.mjs"));
+
+// packages/plugins/experimental/plugin-automation/src/translations.ts
+var translations_default = [
+  {
+    "en-US": {
+      [AUTOMATION_PLUGIN]: {
+        "plugin name": "Automation",
+        "object placeholder": "New prompt",
+        "create object label": "Create prompt",
+        "create trigger label": "Create trigger",
+        "create stack section label": "Create prompt",
+        "command placeholder": "Enter slash command...",
+        "template placeholder": "Enter template...",
+        "value placeholder": "Enter value...",
+        "select preset template placeholder": "Select preset",
+        "open automation panel label": "Show Automations"
+      }
+    }
+  }
+];
+
+// packages/plugins/experimental/plugin-automation/src/AutomationPlugin.tsx
+var __dxlog_file4 = "/home/runner/work/dxos/dxos/packages/plugins/experimental/plugin-automation/src/AutomationPlugin.tsx";
+var AutomationPlugin = () => {
+  return {
+    meta: meta_default,
+    provides: {
+      metadata: {
+        records: {
+          [ChainType.typename]: {
+            placeholder: [
+              "object placeholder",
+              {
+                ns: AUTOMATION_PLUGIN
+              }
+            ],
+            icon: "ph--magic-wand--regular",
+            // TODO(wittjosiah): Move out of metadata.
+            loadReferences: (chain) => loadObjectReferences(chain, (chain2) => chain2.prompts)
+          }
+        }
+      },
+      translations: translations_default,
+      echo: {
+        schema: [
+          ChainType,
+          ChainPromptType,
+          FunctionDef,
+          FunctionTrigger2
+        ]
+      },
+      complementary: {
+        panels: [
+          {
+            id: "automation",
+            label: [
+              "open automation panel label",
+              {
+                ns: AUTOMATION_PLUGIN
+              }
+            ],
+            icon: "ph--flow-arrow--regular"
+          }
+        ]
+      },
+      graph: {
+        builder: (plugins) => {
+          const clientPlugin = resolvePlugin(plugins, parseClientPlugin);
+          const metadataPlugin = resolvePlugin(plugins, parseMetadataResolverPlugin);
+          const resolve = metadataPlugin?.provides.metadata.resolver;
+          const client = clientPlugin?.provides.client;
+          invariant2(resolve, void 0, {
+            F: __dxlog_file4,
+            L: 55,
+            S: void 0,
+            A: [
+              "resolve",
+              ""
+            ]
+          });
+          invariant2(client, void 0, {
+            F: __dxlog_file4,
+            L: 56,
+            S: void 0,
+            A: [
+              "client",
+              ""
+            ]
+          });
+          return [
+            // Create nodes for object settings.
+            createExtension({
+              id: `${AUTOMATION_PLUGIN}/automation-for-subject`,
+              resolver: ({ id }) => {
+                if (!id.endsWith("~automation")) {
+                  return;
+                }
+                const type = "orphan-settings-for-subject";
+                const icon = "ph--flow-arrow--regular";
+                const [subjectId] = id.split("~");
+                const { spaceId, objectId } = parseId(subjectId);
+                const space = client.spaces.get().find((space2) => space2.id === spaceId);
+                if (!objectId) {
+                  const label2 = space ? space.properties.name || [
+                    "unnamed space label",
+                    {
+                      ns: AUTOMATION_PLUGIN
+                    }
+                  ] : [
+                    "unnamed object settings label",
+                    {
+                      ns: AUTOMATION_PLUGIN
+                    }
+                  ];
+                  return {
+                    id,
+                    type,
+                    data: null,
+                    properties: {
+                      icon,
+                      label: label2,
+                      showResolvedThreads: false,
+                      object: null,
+                      space
+                    }
+                  };
+                }
+                const object = toSignal((onChange) => {
+                  const timeout = setTimeout(async () => {
+                    await space?.db.loadObjectById(objectId);
+                    onChange();
+                  });
+                  return () => clearTimeout(timeout);
+                }, () => space?.db.getObjectById(objectId), subjectId);
+                if (!object || !subjectId) {
+                  return;
+                }
+                const meta = resolve(getTypename(object) ?? "");
+                const label = meta.label?.(object) || object.name || meta.placeholder || [
+                  "unnamed object settings label",
+                  {
+                    ns: AUTOMATION_PLUGIN
+                  }
+                ];
+                return {
+                  id,
+                  type,
+                  data: null,
+                  properties: {
+                    icon,
+                    label,
+                    object
+                  }
+                };
+              }
+            })
+          ];
+        }
+      },
+      surface: {
+        component: ({ data, role }) => {
+          switch (role) {
+            // case 'article':
+            // return data.object instanceof ChainType ? <ChainArticle chain={data.object} /> : null;
+            case "complementary--automation":
+              return /* @__PURE__ */ React6.createElement(AutomationPanel, null);
+          }
+          return null;
+        }
+      },
+      intent: {
+        resolver: (intent) => {
+          switch (intent.action) {
+            case AutomationAction.CREATE: {
+              return {};
+            }
+          }
+        }
+      }
+    }
+  };
+};
+
+// packages/plugins/experimental/plugin-automation/src/index.ts
+var src_default = AutomationPlugin;
+export {
+  AutomationAction,
+  AutomationPanel,
+  AutomationPlugin,
+  Chain,
+  ChainInputSchema,
+  ChainInputType,
+  ChainPresets,
+  ChainPromptType,
+  ChainType,
+  PromptContainer,
+  PromptEditor,
+  TriggerEditor,
+  chainPresets,
+  src_default as default,
+  str
+};
+//# sourceMappingURL=index.mjs.map