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

package/src/{components/Settings → containers/ScriptPluginSettings}/ScriptPluginSettings.tsx

@@ -6,14 +6,19 @@ import React from 'react';
 
 import { useClient } from '@dxos/react-client';
 import { Button, Select, useTranslation } from '@dxos/react-ui';
-import { type EditorInputMode, EditorInputModes } from '@dxos/react-ui-editor';
-import { ControlGroup, ControlItemInput, ControlPage, ControlSection } from '@dxos/react-ui-form';
+import { Settings } from '@dxos/react-ui-form';
+import { type EditorInputMode, EditorInputModes } from '@dxos/ui-editor';
 
 import { meta } from '../../meta';
 import { type ScriptSettings } from '../../types';
 import { getAccessCredential } from '../../util';
 
-export const ScriptPluginSettings = ({ settings }: { settings: ScriptSettings }) => {
+export type ScriptPluginSettingsComponentProps = {
+  settings: ScriptSettings;
+  onSettingsChange: (fn: (current: ScriptSettings) => ScriptSettings) => void;
+};
+
+export const ScriptPluginSettings = ({ settings, onSettingsChange }: ScriptPluginSettingsComponentProps) => {
   const { t } = useTranslation(meta.id);
   const client = useClient();
 
@@ -24,19 +29,19 @@ export const ScriptPluginSettings = ({ settings }: { settings: ScriptSettings })
   };
 
   return (
-    <ControlPage>
-      <ControlSection title={t('settings title', { ns: meta.id })}>
-        <ControlGroup>
+    <Settings.Root>
+      <Settings.Section title={t('settings title', { ns: meta.id })}>
+        <Settings.Group>
           {/* TODO(wittjosiah): Hide outside of dev environments. */}
-          <ControlItemInput title={t('authenticate action label')}>
+          <Settings.ItemInput title={t('authenticate action label')}>
             <Button onClick={handleAuthenticate}>{t('authenticate button label')}</Button>
-          </ControlItemInput>
+          </Settings.ItemInput>
 
-          <ControlItemInput title={t('editor input mode label')}>
+          <Settings.ItemInput title={t('editor input mode label')}>
             <Select.Root
               value={settings.editorInputMode ?? 'default'}
               onValueChange={(value) => {
-                settings.editorInputMode = value as EditorInputMode;
+                onSettingsChange((s) => ({ ...s, editorInputMode: value as EditorInputMode }));
               }}
             >
               <Select.TriggerButton placeholder={t('select editor input mode placeholder')} />
@@ -53,9 +58,9 @@ export const ScriptPluginSettings = ({ settings }: { settings: ScriptSettings })
                 </Select.Content>
               </Select.Portal>
             </Select.Root>
-          </ControlItemInput>
-        </ControlGroup>
-      </ControlSection>
-    </ControlPage>
+          </Settings.ItemInput>
+        </Settings.Group>
+      </Settings.Section>
+    </Settings.Root>
   );
 };

package/src/containers/ScriptPluginSettings/index.ts

@@ -0,0 +1,7 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import { ScriptPluginSettings } from './ScriptPluginSettings';
+
+export default ScriptPluginSettings;

package/src/containers/ScriptProperties/ScriptProperties.tsx

@@ -0,0 +1,33 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import React from 'react';
+
+import { Obj } from '@dxos/echo';
+import { type Script } from '@dxos/functions';
+import { Input, useTranslation } from '@dxos/react-ui';
+
+import { meta } from '../../meta';
+
+export type ScriptPropertiesProps = {
+  object: Script.Script;
+};
+
+export const ScriptProperties = ({ object }: ScriptPropertiesProps) => {
+  const { t } = useTranslation(meta.id);
+  return (
+    <Input.Root>
+      <Input.Label>{t('description label')}</Input.Label>
+      <Input.TextInput
+        placeholder={t('description placeholder')}
+        value={object.description ?? ''}
+        onChange={(event) => {
+          Obj.change(object, (obj) => {
+            obj.description = event.target.value;
+          });
+        }}
+      />
+    </Input.Root>
+  );
+};

package/src/containers/ScriptProperties/index.ts

@@ -0,0 +1,7 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import { ScriptProperties } from './ScriptProperties';
+
+export default ScriptProperties;

package/src/containers/TestContainer/TestContainer.tsx

@@ -0,0 +1,45 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import React, { useCallback, useMemo } from 'react';
+
+import { Context } from '@dxos/context';
+
+import { type Script } from '@dxos/functions';
+import { FunctionsServiceClient } from '@dxos/functions-runtime/edge';
+import { Panel } from '@dxos/react-ui';
+import { getSpace } from '@dxos/react-client/echo';
+
+import { TestPanel } from '../../components';
+import { useDeployDeps } from '../../hooks';
+
+export type TestContainerProps = {
+  role: string;
+  script: Script.Script;
+};
+
+export const TestContainer = ({ role, script }: TestContainerProps) => {
+  const { client, fn, existingFunctionId } = useDeployDeps({ script });
+  const space = getSpace(script);
+
+  const functionsClient = useMemo(() => FunctionsServiceClient.fromClient(client), [client]);
+
+  const handleInvoke = useCallback(
+    async (input: unknown) => {
+      if (!fn) {
+        throw new Error('Function not deployed');
+      }
+      return functionsClient.invoke(Context.default(), fn, input, { spaceId: space?.id });
+    },
+    [fn, functionsClient, space?.id],
+  );
+
+  return (
+    <Panel.Root role={role} className='dx-document'>
+      <Panel.Content asChild>
+        <TestPanel onInvoke={existingFunctionId ? handleInvoke : undefined} />
+      </Panel.Content>
+    </Panel.Root>
+  );
+};

package/src/containers/TestContainer/index.ts

@@ -0,0 +1,7 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { TestContainer } from './TestContainer';
+
+export default TestContainer;

package/src/containers/index.ts

@@ -0,0 +1,13 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { type ComponentType, lazy } from 'react';
+
+export const DeploymentDialog: ComponentType<any> = lazy(() => import('./DeploymentDialog'));
+export const NotebookContainer: ComponentType<any> = lazy(() => import('./NotebookContainer'));
+export const ScriptContainer: ComponentType<any> = lazy(() => import('./ScriptContainer'));
+export const ScriptObjectSettings: ComponentType<any> = lazy(() => import('./ScriptObjectSettings'));
+export const ScriptPluginSettings: ComponentType<any> = lazy(() => import('./ScriptPluginSettings'));
+export const ScriptProperties: ComponentType<any> = lazy(() => import('./ScriptProperties'));
+export const TestContainer: ComponentType<any> = lazy(() => import('./TestContainer'));

package/src/e2e/ai.test.ts

@@ -0,0 +1,93 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { describe } from '@effect/vitest';
+import { test } from 'vitest';
+
+import { Client } from '@dxos/client';
+import { type Space } from '@dxos/client-protocol';
+import { configPreset } from '@dxos/config';
+import { Context } from '@dxos/context';
+import { Operation } from '@dxos/operation';
+import { FunctionsServiceClient } from '@dxos/functions-runtime/edge';
+import { bundleFunction } from '@dxos/functions-runtime/native';
+import { FunctionRuntimeKind } from '@dxos/protocols';
+import { EdgeReplicationSetting } from '@dxos/protocols/proto/dxos/echo/metadata';
+
+// To heavy to run in CI.
+describe.runIf(process.env.DX_TEST_TAGS?.includes('functions-e2e')).skip('Function', () => {
+  const config = configPreset({ edge: 'local' });
+
+  test('bundle anthropic function', { timeout: 120_000 }, async () => {
+    await bundleFunction({
+      entryPoint: new URL('../templates/anthropic.ts', import.meta.url).pathname,
+      verbose: true,
+    });
+  });
+
+  test('deploy empty function', { timeout: 120_000 }, async () => {
+    const { space, functionsServiceClient } = await setup();
+
+    await sync(space);
+    const func = await deployFunction(
+      space,
+      functionsServiceClient,
+      new URL('../templates/ping.ts', import.meta.url).pathname,
+    );
+    console.log(func);
+    throw new Error('test');
+  });
+
+  test('deploy and invoke anthropic function', { timeout: 120_000 }, async () => {
+    const { space, functionsServiceClient } = await setup();
+    await sync(space);
+    const func = await deployFunction(
+      space,
+      functionsServiceClient,
+      new URL('../templates/anthropic.ts', import.meta.url).pathname,
+    );
+
+    const result = await functionsServiceClient.invoke(Context.default(), func, {
+      message: 'Hello, world!',
+    });
+    console.log(result);
+  });
+
+  const setup = async () => {
+    const client = await new Client({ config, types: [Operation.PersistentOperation] }).initialize();
+    await client.halo.createIdentity();
+
+    const space = await client.spaces.create();
+    await space.waitUntilReady();
+    await space.internal.setEdgeReplicationPreference(EdgeReplicationSetting.ENABLED);
+
+    const functionsServiceClient = FunctionsServiceClient.fromClient(client);
+    return { client, space, functionsServiceClient };
+  };
+
+  const sync = async (space: Space) => {
+    await space.db.flush();
+    await space.internal.syncToEdge({
+      onProgress: (state) =>
+        console.log(state ? `${state.unsyncedDocumentCount} documents syncing...` : 'connecting to edge...'),
+    });
+  };
+
+  const deployFunction = async (space: Space, functionsServiceClient: FunctionsServiceClient, entryPoint: string) => {
+    const artifact = await bundleFunction({
+      entryPoint,
+      verbose: true,
+    });
+    const func = await functionsServiceClient.deploy(Context.default(), {
+      version: '0.0.1',
+      ownerPublicKey: space.key,
+      entryPoint: artifact.entryPoint,
+      assets: artifact.assets,
+      runtime: FunctionRuntimeKind.enums.WORKER_LOADER,
+    });
+
+    space.db.add(func);
+    return func;
+  };
+});

package/src/e2e/deploy.test.ts

@@ -0,0 +1,65 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { readFile } from 'node:fs/promises';
+
+import { describe, expect, test } from 'vitest';
+
+import { Client, type Config } from '@dxos/client';
+import { createEdgeIdentity } from '@dxos/client/edge';
+import { configPreset } from '@dxos/config';
+import { Context } from '@dxos/context';
+import { bundleFunction } from '@dxos/functions-runtime/bundler';
+import { FunctionsServiceClient } from '@dxos/functions-runtime/edge';
+import { invariant } from '@dxos/invariant';
+import { log } from '@dxos/log';
+
+describe.runIf(process.env.DX_TEST_TAGS?.includes('functions-e2e'))('Functions deployment', () => {
+  test('deploys FOREX (effect) function and invokes it via EDGE (main)', { timeout: 120_000 }, async () => {
+    const config = configPreset({ edge: 'main' });
+    await testDeploy(config);
+  });
+
+  test('deploys FOREX (effect) function and invokes it via EDGE (production)', { timeout: 120_000 }, async () => {
+    const config = configPreset({ edge: 'production' });
+    await testDeploy(config);
+  });
+
+  const testDeploy = async (config: Config) => {
+    await using client = await new Client({ config }).initialize();
+    await client.halo.createIdentity();
+
+    const space = await client.spaces.create();
+    await space.waitUntilReady();
+
+    // Inline echo function source.
+    const source = await readFile(new URL('../templates/forex-effect.ts', import.meta.url), 'utf-8');
+
+    // Bundle and upload.
+    const buildResult = await bundleFunction({ source });
+    if ('error' in buildResult) {
+      throw buildResult.error ?? new Error('Bundle creation failed');
+    }
+    const functionsServiceClient = FunctionsServiceClient.fromClient(client);
+
+    const func = await functionsServiceClient.deploy(Context.default(), {
+      ownerPublicKey: space.key,
+      version: '0.0.1',
+      entryPoint: buildResult.entryPoint,
+      assets: buildResult.assets,
+    });
+
+    // Invoke deployed function via EDGE directly.
+    const edgeClient = client.edge.http;
+    invariant(edgeClient, 'edgeClient is required');
+    edgeClient.setIdentity(createEdgeIdentity(client));
+
+    const input = { from: 'USD', to: 'EUR' };
+    const result = await functionsServiceClient.invoke(Context.default(), func, input);
+    log.info('>>> result', { result, func });
+    const resultNumber = Number(result);
+    expect(resultNumber).toBeGreaterThan(0);
+    expect(resultNumber).toBeLessThan(100);
+  };
+});

package/src/hooks/deploy.ts

@@ -4,13 +4,15 @@
 
 import { useEffect, useMemo } from 'react';
 
-import { Function, type Script, getUserFunctionIdInMetadata } from '@dxos/functions';
+import { Obj, Query, Ref } from '@dxos/echo';
+import { type Script, getUserFunctionIdInMetadata } from '@dxos/functions';
+import { Operation } from '@dxos/operation';
 import { log } from '@dxos/log';
 import { type Client, useClient } from '@dxos/react-client';
-import { Query, Ref, type Space, getMeta, getSpace, useQuery } from '@dxos/react-client/echo';
+import { type Space, getSpace, useQuery } from '@dxos/react-client/echo';
 import { type TFunction } from '@dxos/react-ui';
 import { createMenuAction } from '@dxos/react-ui-menu';
-import { errorMessageColors } from '@dxos/react-ui-theme';
+import { messageValence } from '@dxos/ui-theme';
 
 import { meta } from '../meta';
 import { deployScript, getFunctionUrl, isScriptDeployed } from '../util';
@@ -24,10 +26,12 @@ export type DeployState = {
   error: string;
 };
 
+import { type ScriptToolbarStateStore } from './useToolbarState';
+
 export type CreateDeployOptions = {
-  state: Partial<DeployState>;
+  state: ScriptToolbarStateStore;
   script: Script.Script;
-  fn: Function.Function;
+  fn: Operation.PersistentOperation;
   space?: Space;
   existingFunctionId?: string;
   client: Client;
@@ -35,12 +39,14 @@ export type CreateDeployOptions = {
 };
 
 export const createDeploy = ({ state, script, space, fn, client, existingFunctionId, t }: CreateDeployOptions) => {
+  const { value } = state;
+
   // TODO(wittjosiah): Should this be an action?
   const errorItem = createMenuAction('error', () => {}, {
-    label: state.error ?? ['no error label', { ns: meta.id }],
+    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 && messageValence('error'),
   });
 
   const deployAction = createMenuAction<DeployActionProperties>(
@@ -50,75 +56,78 @@ export const createDeploy = ({ state, script, space, fn, client, existingFunctio
         return;
       }
 
-      state.error = undefined;
-      state.deploying = true;
+      state.set('error', undefined);
+      state.set('deploying', true);
 
       const result = await deployScript({ script, client, space, fn, existingFunctionId });
 
       if (!result.success) {
         log.catch(result.error);
-        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', { ns: meta.id }],
-      icon: state.deploying ? 'ph--spinner-gap--regular' : 'ph--cloud-arrow-up--regular',
-      disabled: state.deploying,
-      classNames: state.deploying ? '[&_svg]:animate-spin' : '',
+      label: [value.deploying ? 'publishing label' : 'deploy label', { ns: meta.id }],
+      icon: value.deploying ? 'ph--spinner-gap--regular' : 'ph--cloud-arrow-up--regular',
+      disabled: value.deploying,
+      classNames: value.deploying ? '[&_svg]:animate-spin' : '',
     },
   );
 
   const copyAction = createMenuAction<DeployActionProperties>(
     'copy',
     async () => {
-      if (state.functionUrl) {
-        await navigator.clipboard.writeText(state.functionUrl);
+      if (value.functionUrl) {
+        await navigator.clipboard.writeText(value.functionUrl);
       }
     },
     {
       type: 'copy',
       label: ['copy link label', { ns: meta.id }],
       icon: 'ph--link--regular',
-      disabled: !state.functionUrl,
+      disabled: !value.functionUrl,
     },
   );
 
   return {
     nodes: [errorItem, deployAction, copyAction],
     edges: [
-      { source: 'root', target: 'error' },
-      { source: 'root', target: 'deploy' },
-      { source: 'root', target: 'copy' },
+      { source: 'root', target: 'error', relation: 'child' },
+      { source: 'root', target: 'deploy', relation: 'child' },
+      { source: 'root', target: 'copy', relation: 'child' },
     ],
   };
 };
 
-export const useDeployState = ({ state, script }: { state: Partial<DeployState>; script: Script.Script }) => {
+export const useDeployState = ({ state, script }: { state: ScriptToolbarStateStore; script: Script.Script }) => {
   const { space, client, fn, existingFunctionId } = useDeployDeps({ script });
   useEffect(() => {
     if (!existingFunctionId) {
       return;
     }
 
-    state.functionUrl = getFunctionUrl({
-      script,
-      fn,
-      edgeUrl: client.config.values.runtime?.services?.edge?.url ?? '',
-    });
-  }, [existingFunctionId, space, fn, script, client.config.values.runtime?.services?.edge?.url]);
+    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, state]);
 
   useEffect(() => {
-    state.deployed = isScriptDeployed({ script, fn });
-  }, [script.changed, existingFunctionId, fn, script]);
+    state.set('deployed', isScriptDeployed({ script, fn }));
+  }, [script.changed, existingFunctionId, fn, script, state]);
 };
 
 export const useDeployDeps = ({ script }: { script: Script.Script }) => {
   const client = useClient();
   const space = getSpace(script);
-  const [fn] = useQuery(space, Query.type(Function.Function, { source: Ref.make(script) }));
-  const existingFunctionId = useMemo(() => fn && getUserFunctionIdInMetadata(getMeta(fn)), [fn]);
+  const [fn] = useQuery(space?.db, Query.type(Operation.PersistentOperation, { source: Ref.make(script) }));
+  const existingFunctionId = useMemo(() => fn && getUserFunctionIdInMetadata(Obj.getMeta(fn)), [fn]);
   return { client, space, fn, existingFunctionId };
 };

package/src/hooks/format.ts

@@ -6,6 +6,7 @@ import { format } from 'prettier';
 import prettierPluginEstree from 'prettier/plugins/estree';
 import prettierPluginTypescript from 'prettier/plugins/typescript';
 
+import { Obj } from '@dxos/echo';
 import { type Script } from '@dxos/functions';
 import { log } from '@dxos/log';
 import { createMenuAction } from '@dxos/react-ui-menu';
@@ -23,12 +24,15 @@ export const createFormat = (script: Script.Script) => {
       }
 
       try {
-        script.source.target!.content = await format(script.source.target!.content, {
+        const formatted = await format(script.source.target!.content, {
           parser: 'typescript',
           plugins: [prettierPluginEstree, prettierPluginTypescript],
           semi: true,
           singleQuote: true,
         });
+        Obj.change(script.source.target!, (obj) => {
+          obj.content = formatted;
+        });
       } catch (err: any) {
         // TODO(wittjosiah): Show error in UI.
         log.catch(err);
@@ -46,6 +50,7 @@ export const createFormat = (script: Script.Script) => {
       {
         source: 'root',
         target: 'format',
+        relation: 'child',
       },
     ],
   };

package/src/hooks/index.ts

@@ -8,3 +8,4 @@ export * from './template';
 
 export * from './useCreateAndDeployScriptTemplates';
 export * from './useToolbarState';
+export * from './useCompiler';

package/src/hooks/template.ts

@@ -15,15 +15,21 @@ const createTemplateSelectActions = (script: Script.Script) => {
     return createMenuAction<TemplateActionProperties>(
       `template--${template.id}`,
       () => {
-        script.name = template.name;
-        script.source!.target!.content = template.source;
-        const metaKeys = Obj.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 });
+        Obj.change(script, (obj) => {
+          obj.name = template.name;
+          const meta = Obj.getMeta(obj);
+          const oldPresetIndex = meta.keys.findIndex((key) => key.source === FUNCTIONS_PRESET_META_KEY);
+          if (oldPresetIndex >= 0) {
+            meta.keys.splice(oldPresetIndex, 1);
+          }
+          if ('presetId' in template) {
+            meta.keys.push({ source: FUNCTIONS_PRESET_META_KEY, id: template.presetId });
+          }
+        });
+        if (script.source?.target) {
+          Obj.change(script.source.target, (obj) => {
+            obj.content = template.source;
+          });
         }
       },
       {
@@ -40,8 +46,8 @@ export const createTemplateSelect = (script: Script.Script) => {
   return {
     nodes: [...templateSelectActions],
     edges: [
-      { source: 'root', target: 'template-select' },
-      ...templateSelectActions.map((action) => ({ source: 'template-select', target: action.id })),
+      { source: 'root', target: 'template-select', relation: 'child' },
+      ...templateSelectActions.map((action) => ({ source: 'template-select', target: action.id, relation: 'child' })),
     ],
   };
 };

package/src/hooks/useCompiler.ts

@@ -0,0 +1,24 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { useCapabilities, usePluginManager } from '@dxos/app-framework/ui';
+import { runAndForwardErrors } from '@dxos/effect';
+import { useAsyncEffect } from '@dxos/react-ui';
+
+import type { Compiler } from '../compiler';
+import { ScriptEvents } from '../types';
+import { ScriptCapabilities } from '../types';
+
+/**
+ * Asynchronously sets up the compiler and returns it.
+ * @returns The compiler instance or undefined if it is not ready.
+ */
+export const useCompiler = (): Compiler | undefined => {
+  const manager = usePluginManager();
+  useAsyncEffect(async () => {
+    await manager.activate(ScriptEvents.SetupCompiler).pipe(runAndForwardErrors);
+  }, [manager]);
+  const [compiler] = useCapabilities(ScriptCapabilities.Compiler);
+  return compiler;
+};