@dxos/plugin-script 0.8.4-main.72ec0f3 → 0.8.4-main.937b3ca

package/dist/lib/node-esm/{chunk-IQTBVH4L.mjs → chunk-MGWKULCD.mjs}

@@ -1,111 +1,26 @@
 import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
 import {
-  ScriptAction
-} from "./chunk-NNHWLRHT.mjs";
+  ScriptCapabilities,
+  ScriptEvents,
+  ScriptOperation
+} from "./chunk-KN6SQYUF.mjs";
 import {
   templates
-} from "./chunk-57JA6XL5.mjs";
+} from "./chunk-4F5FJZ36.mjs";
 import {
   meta
-} from "./chunk-IBV2DR36.mjs";
-
-// src/util/functions.ts
-import { getUserFunctionIdInMetadata } from "@dxos/functions";
-import { getInvocationUrl } from "@dxos/functions-runtime";
-import { log } from "@dxos/log";
-import { getMeta, getSpace } from "@dxos/react-client/echo";
-var __dxlog_file = "/__w/dxos/dxos/packages/plugins/plugin-script/src/util/functions.ts";
-var getFunctionUrl = ({ script, fn, edgeUrl }) => {
-  const space = getSpace(script);
-  const existingFunctionId = fn && getUserFunctionIdInMetadata(getMeta(fn));
-  if (!existingFunctionId) {
-    return void 0;
-  }
-  return getInvocationUrl(existingFunctionId, edgeUrl, {
-    spaceId: space?.id
-  });
-};
-var updateFunctionMetadata = (script, storedFunction, meta2, functionId) => {
-  if (script.description !== void 0 && script.description.trim() !== "") {
-    storedFunction.description = script.description;
-  } else if (meta2.description) {
-    storedFunction.description = meta2.description;
-  } else {
-    log.verbose("no description in function metadata", {
-      functionId
-    }, {
-      F: __dxlog_file,
-      L: 46,
-      S: void 0,
-      C: (f, a) => f(...a)
-    });
-  }
-  if (meta2.inputSchema) {
-    storedFunction.inputSchema = meta2.inputSchema;
-  } else {
-    log.verbose("no input schema in function metadata", {
-      functionId
-    }, {
-      F: __dxlog_file,
-      L: 52,
-      S: void 0,
-      C: (f, a) => f(...a)
-    });
-  }
-  if (meta2.outputSchema) {
-    storedFunction.outputSchema = meta2.outputSchema;
-  } else {
-    log.verbose("no output schema in function metadata", {
-      functionId
-    }, {
-      F: __dxlog_file,
-      L: 58,
-      S: void 0,
-      C: (f, a) => f(...a)
-    });
-  }
-  if (meta2.key) {
-    storedFunction.key = meta2.key;
-  } else {
-    log.verbose("no key in function metadata", {
-      functionId
-    }, {
-      F: __dxlog_file,
-      L: 64,
-      S: void 0,
-      C: (f, a) => f(...a)
-    });
-  }
-};
-var getAccessCredential = (identityKey) => {
-  return {
-    issuer: identityKey,
-    issuanceDate: /* @__PURE__ */ new Date(),
-    subject: {
-      id: identityKey,
-      assertion: {
-        "@type": "dxos.halo.credentials.ServiceAccess",
-        serverName: "hub.dxos.network",
-        serverKey: identityKey,
-        identityKey,
-        capabilities: [
-          "composer:beta"
-        ]
-      }
-    }
-  };
-};
+} from "./chunk-5HSJPAK7.mjs";
 
 // src/util/deploy.ts
 import { Obj, Ref } from "@dxos/echo";
-import { Function, getUserFunctionIdInMetadata as getUserFunctionIdInMetadata2, setUserFunctionIdInMetadata } from "@dxos/functions";
-import { Bundler } from "@dxos/functions-runtime/bundler";
-import { incrementSemverPatch, uploadWorkerFunction } from "@dxos/functions-runtime/edge";
-import { log as log2 } from "@dxos/log";
-import { isNode } from "@dxos/util";
-var __dxlog_file2 = "/__w/dxos/dxos/packages/plugins/plugin-script/src/util/deploy.ts";
+import { Function, getUserFunctionIdInMetadata } from "@dxos/functions";
+import { bundleFunction } from "@dxos/functions-runtime/bundler";
+import { FunctionsServiceClient, incrementSemverPatch } from "@dxos/functions-runtime/edge";
+import { log } from "@dxos/log";
+import { FunctionRuntimeKind } from "@dxos/protocols";
+var __dxlog_file = "/__w/dxos/dxos/packages/plugins/plugin-script/src/util/deploy.ts";
 var isScriptDeployed = ({ script, fn }) => {
-  const existingFunctionId = fn && getUserFunctionIdInMetadata2(Obj.getMeta(fn));
+  const existingFunctionId = fn && getUserFunctionIdInMetadata(Obj.getMeta(fn));
   return Boolean(existingFunctionId) && !script.changed;
 };
 var deployScript = async ({ script, client, space, fn, existingFunctionId }) => {
@@ -117,45 +32,34 @@ var deployScript = async ({ script, client, space, fn, existingFunctionId }) =>
     };
   }
   try {
-    const bundler = new Bundler({
-      platform: isNode() ? "node" : "browser",
-      sandboxedModules: [],
-      remoteModules: {}
-    });
-    const buildResult = await bundler.bundle({
+    const buildResult = await bundleFunction({
       source: script.source.target.content
     });
     if ("error" in buildResult) {
       throw buildResult.error || new Error("Bundle creation failed");
     }
-    const { functionId, version, meta: meta2 } = await uploadWorkerFunction({
-      client,
+    const functionsServiceClient = FunctionsServiceClient.fromClient(client);
+    const newFunction = await functionsServiceClient.deploy({
+      // TODO(dmaretskyi): Space key or identity key.
       ownerPublicKey: space.key,
       version: fn ? incrementSemverPatch(fn.version) : "0.0.1",
       functionId: existingFunctionId,
       entryPoint: buildResult.entryPoint,
-      assets: {
-        [buildResult.entryPoint]: buildResult.asset
-      }
+      assets: buildResult.assets,
+      runtime: FunctionRuntimeKind.enums.WORKER_LOADER
+    });
+    const storedFunction = createOrUpdateFunctionInSpace(space, fn, script, newFunction);
+    Obj.change(script, (s) => {
+      s.changed = false;
     });
-    if (functionId === void 0 || version === void 0) {
-      throw new Error(`Upload didn't return expected data: ${JSON.stringify({
-        functionId,
-        version
-      })}`);
-    }
-    const storedFunction = createOrUpdateFunctionInSpace(space, fn, script, functionId, version);
-    script.changed = false;
-    updateFunctionMetadata(script, storedFunction, meta2, functionId);
-    setUserFunctionIdInMetadata(Obj.getMeta(storedFunction), functionId);
     return {
       success: true,
-      functionId
+      functionId: getUserFunctionIdInMetadata(Obj.getMeta(storedFunction))
     };
   } catch (err) {
-    log2.catch(err, void 0, {
-      F: __dxlog_file2,
-      L: 74,
+    log.catch(err, void 0, {
+      F: __dxlog_file,
+      L: 70,
       S: void 0,
       C: (f, a) => f(...a)
     });
@@ -171,51 +75,138 @@ var validateDeployInputs = (script, space) => {
   }
   return null;
 };
-var createOrUpdateFunctionInSpace = (space, fn, script, functionId, version) => {
+var createOrUpdateFunctionInSpace = (space, fn, script, newFunction) => {
   if (fn) {
-    fn.name = script.name ?? "New Function";
-    fn.version = version;
+    Function.setFrom(fn, newFunction);
     return fn;
   } else {
-    const fn2 = Function.make({
-      name: script.name ?? "New Function",
-      version,
-      source: Ref.make(script)
+    Obj.change(newFunction, (f) => {
+      f.source = Ref.make(script);
     });
-    space.db.add(fn2);
-    setUserFunctionIdInMetadata(Obj.getMeta(fn2), functionId);
-    return fn2;
+    return space.db.add(newFunction);
+  }
+};
+
+// src/util/functions.ts
+import { Obj as Obj2 } from "@dxos/echo";
+import { getUserFunctionIdInMetadata as getUserFunctionIdInMetadata2 } from "@dxos/functions";
+import { getInvocationUrl } from "@dxos/functions-runtime";
+import { log as log2 } from "@dxos/log";
+import { getSpace } from "@dxos/react-client/echo";
+var __dxlog_file2 = "/__w/dxos/dxos/packages/plugins/plugin-script/src/util/functions.ts";
+var getFunctionUrl = ({ script, fn, edgeUrl }) => {
+  const space = getSpace(script);
+  const existingFunctionId = fn && getUserFunctionIdInMetadata2(Obj2.getMeta(fn));
+  if (!existingFunctionId) {
+    return void 0;
   }
+  return getInvocationUrl(existingFunctionId, edgeUrl, {
+    spaceId: space?.id
+  });
+};
+var updateFunctionMetadata = (script, storedFunction, meta2, functionId) => {
+  Obj2.change(storedFunction, (f) => {
+    if (script.description !== void 0 && script.description.trim() !== "") {
+      f.description = script.description;
+    } else if (meta2.description) {
+      f.description = meta2.description;
+    } else {
+      log2.verbose("no description in function metadata", {
+        functionId
+      }, {
+        F: __dxlog_file2,
+        L: 48,
+        S: void 0,
+        C: (f2, a) => f2(...a)
+      });
+    }
+    if (meta2.inputSchema) {
+      f.inputSchema = meta2.inputSchema;
+    } else {
+      log2.verbose("no input schema in function metadata", {
+        functionId
+      }, {
+        F: __dxlog_file2,
+        L: 54,
+        S: void 0,
+        C: (f2, a) => f2(...a)
+      });
+    }
+    if (meta2.outputSchema) {
+      f.outputSchema = meta2.outputSchema;
+    } else {
+      log2.verbose("no output schema in function metadata", {
+        functionId
+      }, {
+        F: __dxlog_file2,
+        L: 60,
+        S: void 0,
+        C: (f2, a) => f2(...a)
+      });
+    }
+    if (meta2.key) {
+      f.key = meta2.key;
+    } else {
+      log2.verbose("no key in function metadata", {
+        functionId
+      }, {
+        F: __dxlog_file2,
+        L: 66,
+        S: void 0,
+        C: (f2, a) => f2(...a)
+      });
+    }
+  });
+};
+var getAccessCredential = (identityKey) => {
+  return {
+    issuer: identityKey,
+    issuanceDate: /* @__PURE__ */ new Date(),
+    subject: {
+      id: identityKey,
+      assertion: {
+        "@type": "dxos.halo.credentials.ServiceAccess",
+        serverName: "hub.dxos.network",
+        serverKey: identityKey,
+        identityKey,
+        capabilities: [
+          "composer:beta"
+        ]
+      }
+    }
+  };
 };
 
 // src/hooks/deploy.ts
 import { useEffect, useMemo } from "react";
+import { Obj as Obj3, Query, Ref as Ref2 } from "@dxos/echo";
 import { Function as Function2, getUserFunctionIdInMetadata as getUserFunctionIdInMetadata3 } from "@dxos/functions";
 import { log as log3 } from "@dxos/log";
 import { useClient } from "@dxos/react-client";
-import { Query, Ref as Ref2, getMeta as getMeta2, getSpace as getSpace2, useQuery } from "@dxos/react-client/echo";
+import { getSpace as getSpace2, useQuery } from "@dxos/react-client/echo";
 import { createMenuAction } from "@dxos/react-ui-menu";
-import { errorMessageColors } from "@dxos/react-ui-theme";
+import { errorMessageColors } from "@dxos/ui-theme";
 var __dxlog_file3 = "/__w/dxos/dxos/packages/plugins/plugin-script/src/hooks/deploy.ts";
 var createDeploy = ({ state, script, space, fn, client, existingFunctionId, t }) => {
+  const { value } = state;
   const errorItem = createMenuAction("error", () => {
   }, {
-    label: state.error ?? [
+    label: value.error ?? [
       "no error label",
       {
         ns: meta.id
       }
     ],
     icon: "ph--warning-circle--regular",
-    hidden: !state.error,
-    classNames: state.error && errorMessageColors
+    hidden: !value.error,
+    classNames: value.error && errorMessageColors
   });
   const deployAction = createMenuAction("deploy", async () => {
     if (!script.source || !space) {
       return;
     }
-    state.error = void 0;
-    state.deploying = true;
+    state.set("error", void 0);
+    state.set("deploying", true);
     const result = await deployScript({
       script,
       client,
@@ -226,28 +217,28 @@ var createDeploy = ({ state, script, space, fn, client, existingFunctionId, t })
     if (!result.success) {
       log3.catch(result.error, void 0, {
         F: __dxlog_file3,
-        L: 59,
+        L: 64,
         S: void 0,
         C: (f, a) => f(...a)
       });
-      state.error = t("upload failed label");
+      state.set("error", t("upload failed label"));
     }
-    state.deploying = false;
+    state.set("deploying", false);
   }, {
     type: "deploy",
     label: [
-      state.deploying ? "publishing label" : "deploy label",
+      value.deploying ? "publishing label" : "deploy label",
       {
         ns: meta.id
       }
     ],
-    icon: state.deploying ? "ph--spinner-gap--regular" : "ph--cloud-arrow-up--regular",
-    disabled: state.deploying,
-    classNames: state.deploying ? "[&_svg]:animate-spin" : ""
+    icon: value.deploying ? "ph--spinner-gap--regular" : "ph--cloud-arrow-up--regular",
+    disabled: value.deploying,
+    classNames: value.deploying ? "[&_svg]:animate-spin" : ""
   });
   const copyAction = createMenuAction("copy", async () => {
-    if (state.functionUrl) {
-      await navigator.clipboard.writeText(state.functionUrl);
+    if (value.functionUrl) {
+      await navigator.clipboard.writeText(value.functionUrl);
     }
   }, {
     type: "copy",
@@ -258,7 +249,7 @@ var createDeploy = ({ state, script, space, fn, client, existingFunctionId, t })
       }
     ],
     icon: "ph--link--regular",
-    disabled: !state.functionUrl
+    disabled: !value.functionUrl
   });
   return {
     nodes: [
@@ -290,37 +281,39 @@ var useDeployState = ({ state, script }) => {
     if (!existingFunctionId) {
       return;
     }
-    state.functionUrl = getFunctionUrl({
+    state.set("functionUrl", getFunctionUrl({
       script,
       fn,
       edgeUrl: client.config.values.runtime?.services?.edge?.url ?? ""
-    });
+    }));
   }, [
     existingFunctionId,
     space,
     fn,
     script,
-    client.config.values.runtime?.services?.edge?.url
+    client.config.values.runtime?.services?.edge?.url,
+    state
   ]);
   useEffect(() => {
-    state.deployed = isScriptDeployed({
+    state.set("deployed", isScriptDeployed({
       script,
       fn
-    });
+    }));
   }, [
     script.changed,
     existingFunctionId,
     fn,
-    script
+    script,
+    state
   ]);
 };
 var useDeployDeps = ({ script }) => {
   const client = useClient();
   const space = getSpace2(script);
-  const [fn] = useQuery(space, Query.type(Function2.Function, {
+  const [fn] = useQuery(space?.db, Query.type(Function2.Function, {
     source: Ref2.make(script)
   }));
-  const existingFunctionId = useMemo(() => fn && getUserFunctionIdInMetadata3(getMeta2(fn)), [
+  const existingFunctionId = useMemo(() => fn && getUserFunctionIdInMetadata3(Obj3.getMeta(fn)), [
     fn
   ]);
   return {
@@ -332,16 +325,53 @@ var useDeployDeps = ({ script }) => {
 };
 
 // src/hooks/useToolbarState.ts
-import { useMemo as useMemo2 } from "react";
-import { live } from "@dxos/live-object";
+import { Atom, RegistryContext, useAtomValue } from "@effect-atom/atom-react";
+import { useContext, useMemo as useMemo2 } from "react";
 var useToolbarState = (initialState = {}) => {
-  return useMemo2(() => live(initialState), []);
+  const registry = useContext(RegistryContext);
+  const atom = useMemo2(() => Atom.make(initialState), []);
+  const value = useAtomValue(atom);
+  return useMemo2(() => ({
+    atom,
+    get value() {
+      return registry.get(atom);
+    },
+    update: (updater) => {
+      registry.set(atom, updater(registry.get(atom)));
+    },
+    set: (key, v) => {
+      registry.set(atom, {
+        ...registry.get(atom),
+        [key]: v
+      });
+    }
+  }), [
+    atom,
+    registry,
+    value
+  ]);
+};
+
+// src/hooks/useCompiler.ts
+import { useCapabilities, usePluginManager } from "@dxos/app-framework/react";
+import { runAndForwardErrors } from "@dxos/effect";
+import { useAsyncEffect } from "@dxos/react-ui";
+var useCompiler = () => {
+  const manager = usePluginManager();
+  useAsyncEffect(async () => {
+    await manager.activate(ScriptEvents.SetupCompiler).pipe(runAndForwardErrors);
+  }, [
+    manager
+  ]);
+  const [compiler] = useCapabilities(ScriptCapabilities.Compiler);
+  return compiler;
 };
 
 // src/hooks/format.ts
 import { format } from "prettier";
 import prettierPluginEstree from "prettier/plugins/estree";
 import prettierPluginTypescript from "prettier/plugins/typescript";
+import { Obj as Obj4 } from "@dxos/echo";
 import { log as log4 } from "@dxos/log";
 import { createMenuAction as createMenuAction2 } from "@dxos/react-ui-menu";
 var __dxlog_file4 = "/__w/dxos/dxos/packages/plugins/plugin-script/src/hooks/format.ts";
@@ -351,7 +381,7 @@ var createFormat = (script) => {
       return;
     }
     try {
-      script.source.target.content = await format(script.source.target.content, {
+      const formatted = await format(script.source.target.content, {
         parser: "typescript",
         plugins: [
           prettierPluginEstree,
@@ -360,10 +390,13 @@ var createFormat = (script) => {
         semi: true,
         singleQuote: true
       });
+      Obj4.change(script.source.target, (s) => {
+        s.content = formatted;
+      });
     } catch (err) {
       log4.catch(err, void 0, {
         F: __dxlog_file4,
-        L: 34,
+        L: 38,
         S: void 0,
         C: (f, a) => f(...a)
       });
@@ -391,23 +424,29 @@ var createFormat = (script) => {
 };
 
 // src/hooks/template.ts
-import { Obj as Obj2 } from "@dxos/echo";
+import { Obj as Obj5 } from "@dxos/echo";
 import { FUNCTIONS_PRESET_META_KEY } from "@dxos/functions";
 import { createMenuAction as createMenuAction3 } from "@dxos/react-ui-menu";
 var createTemplateSelectActions = (script) => {
   return templates.map((template) => {
     return createMenuAction3(`template--${template.id}`, () => {
-      script.name = template.name;
-      script.source.target.content = template.source;
-      const metaKeys = Obj2.getMeta(script).keys;
-      const oldPresetIndex = metaKeys.findIndex((key) => key.source === FUNCTIONS_PRESET_META_KEY);
-      if (oldPresetIndex >= 0) {
-        metaKeys.splice(oldPresetIndex, 1);
-      }
-      if ("presetId" in template) {
-        metaKeys.push({
-          source: FUNCTIONS_PRESET_META_KEY,
-          id: template.presetId
+      Obj5.change(script, (s) => {
+        s.name = template.name;
+        const meta2 = Obj5.getMeta(s);
+        const oldPresetIndex = meta2.keys.findIndex((key) => key.source === FUNCTIONS_PRESET_META_KEY);
+        if (oldPresetIndex >= 0) {
+          meta2.keys.splice(oldPresetIndex, 1);
+        }
+        if ("presetId" in template) {
+          meta2.keys.push({
+            source: FUNCTIONS_PRESET_META_KEY,
+            id: template.presetId
+          });
+        }
+      });
+      if (script.source?.target) {
+        Obj5.change(script.source.target, (s) => {
+          s.content = template.source;
         });
       }
     }, {
@@ -437,25 +476,23 @@ var createTemplateSelect = (script) => {
 };
 
 // src/hooks/useCreateAndDeployScriptTemplates.ts
-import * as Function3 from "effect/Function";
 import { useCallback, useState } from "react";
-import { chain, createIntent } from "@dxos/app-framework";
-import { useIntentDispatcher } from "@dxos/app-framework/react";
-import { Obj as Obj3 } from "@dxos/echo";
+import { useOperationInvoker } from "@dxos/app-framework/react";
+import { Obj as Obj6 } from "@dxos/echo";
 import { Script } from "@dxos/functions";
 import { invariant } from "@dxos/invariant";
-import { SpaceAction } from "@dxos/plugin-space/types";
+import { SpaceOperation } from "@dxos/plugin-space/types";
 import { useClient as useClient2 } from "@dxos/react-client";
 var __dxlog_file5 = "/__w/dxos/dxos/packages/plugins/plugin-script/src/hooks/useCreateAndDeployScriptTemplates.ts";
 var useCreateAndDeployScriptTemplates = (space, scriptTemplates) => {
-  const { dispatchPromise: dispatch } = useIntentDispatcher();
+  const { invokePromise } = useOperationInvoker();
   const client = useClient2();
   const [status, setStatus] = useState("idle");
   const [error, setError] = useState(void 0);
   const handleCreateAndDeployScripts = useCallback(async () => {
     invariant(space, void 0, {
       F: __dxlog_file5,
-      L: 37,
+      L: 35,
       S: void 0,
       A: [
         "space",
@@ -465,32 +502,34 @@ var useCreateAndDeployScriptTemplates = (space, scriptTemplates) => {
     setStatus("pending");
     setError(void 0);
     const deploymentResults = await Promise.all(scriptTemplates.map(async (template) => {
-      const result = await dispatch(Function3.pipe(createIntent(ScriptAction.CreateScript, {
-        space,
+      const createResult = await invokePromise(ScriptOperation.CreateScript, {
+        db: space.db,
         initialTemplateId: template.id
-      }), chain(SpaceAction.AddObject, {
-        target: space
-      })));
-      invariant(Obj3.instanceOf(Script.Script, result.data?.object), void 0, {
+      });
+      invariant(Obj6.instanceOf(Script.Script, createResult.data?.object), void 0, {
         F: __dxlog_file5,
-        L: 52,
+        L: 45,
         S: void 0,
         A: [
-          "Obj.instanceOf(Script.Script, result.data?.object)",
+          "Obj.instanceOf(Script.Script, createResult.data?.object)",
           ""
         ]
       });
+      await invokePromise(SpaceOperation.AddObject, {
+        target: space.db,
+        object: createResult.data.object
+      });
       return deployScript({
         space,
         client,
-        script: result.data.object
+        script: createResult.data.object
       });
     }));
     const hasErrors = deploymentResults.some((result) => !result.success);
     setStatus(hasErrors ? "error" : "success");
   }, [
     space,
-    dispatch,
+    invokePromise,
     client,
     scriptTemplates
   ]);
@@ -502,17 +541,18 @@ var useCreateAndDeployScriptTemplates = (space, scriptTemplates) => {
 };
 
 export {
+  isScriptDeployed,
+  deployScript,
   getFunctionUrl,
   updateFunctionMetadata,
   getAccessCredential,
-  isScriptDeployed,
-  deployScript,
   createDeploy,
   useDeployState,
   useDeployDeps,
   createFormat,
   createTemplateSelect,
   useCreateAndDeployScriptTemplates,
-  useToolbarState
+  useToolbarState,
+  useCompiler
 };
-//# sourceMappingURL=chunk-IQTBVH4L.mjs.map
+//# sourceMappingURL=chunk-MGWKULCD.mjs.map