@dxos/plugin-script 0.8.4-main.2e9d522 → 0.8.4-main.3c1ae3b

package/src/components/QueryEditor/QueryEditor.stories.tsx

@@ -0,0 +1,89 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import { type Meta, type StoryObj } from '@storybook/react-vite';
+import React, { useCallback, useMemo, useState } from 'react';
+
+import { createDocAccessor } from '@dxos/echo-db';
+import { QuerySandbox } from '@dxos/echo-query';
+import { createObject } from '@dxos/react-client/echo';
+import { Toolbar, useAsyncEffect } from '@dxos/react-ui';
+import { withLayout, withTheme } from '@dxos/react-ui/testing';
+import { createDataExtensions } from '@dxos/react-ui-editor';
+import { StackItem } from '@dxos/react-ui-stack';
+import { Json } from '@dxos/react-ui-syntax-highlighter';
+import { trim } from '@dxos/util';
+
+import { QueryEditor, type QueryEditorProps } from './QueryEditor';
+
+const SCRIPT = trim`
+  Query.select(Filter.type('dxos.org/type/Person'))
+`;
+
+const DefaultStory = (props: QueryEditorProps) => {
+  const object = useMemo(() => createObject({ content: SCRIPT }), []);
+  const [result, setResult] = useState<object | undefined>({});
+  const [sandbox, setSandbox] = useState<QuerySandbox>();
+
+  useAsyncEffect(async () => {
+    const sandbox = new QuerySandbox();
+    await sandbox.open();
+    setSandbox(sandbox);
+
+    return () => {
+      void sandbox.close();
+    };
+  }, []);
+
+  const extensions = useMemo(
+    () => [createDataExtensions({ id: object.id, text: createDocAccessor(object, ['content']) })],
+    [],
+  );
+
+  const handleRun = useCallback(async () => {
+    try {
+      const result = sandbox?.eval(object.content);
+
+      setResult({
+        timestamp: Date.now(),
+        result,
+      });
+    } catch (err) {
+      setResult({
+        timestamp: Date.now(),
+        error: String(err),
+      });
+    }
+  }, [object, sandbox]);
+
+  return (
+    <StackItem.Content toolbar>
+      {/* <ScriptToolbar script={script} state={{}} /> */}
+      <Toolbar.Root>
+        <Toolbar.Button onClick={handleRun}>Run</Toolbar.Button>
+      </Toolbar.Root>
+      <div role='none' className='grid grid-rows-[1fr_min-content] bs-full overflow-hidden text-sm'>
+        <QueryEditor {...props} initialValue={object.content} extensions={extensions} />
+        <Json data={result} classNames='shrink-0 p-2 border-t border-subduedSeparator' />
+      </div>
+    </StackItem.Content>
+  );
+};
+
+const meta = {
+  title: 'plugins/plugin-script/QueryEditor',
+  component: QueryEditor,
+  render: DefaultStory,
+  decorators: [withTheme, withLayout({ container: 'column', classNames: 'is-prose' })],
+} satisfies Meta<typeof DefaultStory>;
+
+export default meta;
+
+type Story = StoryObj<typeof meta>;
+
+export const Default: Story = {
+  args: {
+    id: 'test',
+  },
+};

package/src/components/QueryEditor/QueryEditor.tsx

@@ -0,0 +1,47 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import React, { useState } from 'react';
+import { ScriptTarget } from 'typescript';
+
+import queryApi from '@dxos/echo-query/api.d.ts?raw';
+import { useAsyncEffect } from '@dxos/react-ui';
+
+import { Compiler } from '../../compiler';
+import { TypescriptEditor, type TypescriptEditorProps } from '../TypescriptEditor';
+
+const GLOBALS = `
+  namespace QueryAPI {
+    ${queryApi}
+  }
+
+  declare global {
+    const Query: typeof QueryAPI.Query;
+    const Filter: typeof QueryAPI.Filter;
+    const Order: typeof QueryAPI.Order;
+  }
+
+  export {};
+`;
+
+export type QueryEditorProps = Omit<TypescriptEditorProps, 'env'>;
+
+export const QueryEditor = (props: QueryEditorProps) => {
+  const [compiler, setCompiler] = useState<Compiler>();
+
+  useAsyncEffect(async () => {
+    const compiler = new Compiler({
+      lib: ['ES5'],
+      target: ScriptTarget.ES2022,
+    });
+    await compiler.initialize(GLOBALS);
+    setCompiler(compiler);
+  }, []);
+
+  if (!compiler) {
+    return null;
+  }
+
+  return <TypescriptEditor {...props} env={compiler.environment} />;
+};

package/src/components/QueryEditor/index.ts

@@ -0,0 +1,5 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+export * from './QueryEditor';

package/src/components/ScriptContainer.tsx

@@ -4,21 +4,23 @@
 
 import React, { useMemo } from 'react';
 
-import { type ScriptType } from '@dxos/functions';
-import { createDocAccessor, getSpace } from '@dxos/react-client/echo';
+import { createDocAccessor } from '@dxos/echo-db';
+import { type Script } from '@dxos/functions';
+import { getSpace } from '@dxos/react-client/echo';
 import { useIdentity } from '@dxos/react-client/halo';
 import { createDataExtensions, listener, stackItemContentEditorClassNames } from '@dxos/react-ui-editor';
 import { StackItem } from '@dxos/react-ui-stack';
 
+import { useDeployState, useToolbarState } from '../hooks';
+import { type ScriptSettings } from '../types';
+
 import { ScriptToolbar } from './ScriptToolbar';
 import { TypescriptEditor, type TypescriptEditorProps } from './TypescriptEditor';
-import { useDeployState, useToolbarState } from '../hooks';
-import { type ScriptSettingsProps } from '../types';
 
 export type ScriptEditorProps = {
   role: string;
-  script: ScriptType;
-  settings?: ScriptSettingsProps;
+  script: Script.Script;
+  settings?: ScriptSettings;
 } & Pick<TypescriptEditorProps, 'env'>;
 
 export const ScriptContainer = ({ role, script, settings = { editorInputMode: 'vscode' }, env }: ScriptEditorProps) => {
@@ -32,7 +34,7 @@ export const ScriptContainer = ({ role, script, settings = { editorInputMode: 'v
       script.source.target
         ? [
             listener({
-              onChange: (text) => {
+              onChange: ({ text }) => {
                 if (script.source.target?.content !== text) {
                   script.changed = true;
                 }
@@ -41,7 +43,7 @@ export const ScriptContainer = ({ role, script, settings = { editorInputMode: 'v
             createDataExtensions({
               id: script.id,
               text: createDocAccessor(script.source.target, ['content']),
-              space,
+              messenger: space,
               identity,
             }),
           ]

package/src/components/ScriptToolbar/ScriptToolbar.stories.tsx

@@ -2,29 +2,46 @@
 // Copyright 2023 DXOS.org
 //
 
-import '@dxos-theme';
+import { type Meta, type StoryObj } from '@storybook/react-vite';
 
-import { type Meta } from '@storybook/react-vite';
+import { IntentPlugin } from '@dxos/app-framework';
+import { withPluginManager } from '@dxos/app-framework/testing';
+import { Script } from '@dxos/functions';
+import { ClientPlugin } from '@dxos/plugin-client';
+import { withLayout, withTheme } from '@dxos/react-ui/testing';
 
-import { withLayout, withTheme } from '@dxos/storybook-utils';
+import { translations } from '../../translations';
 
 import { ScriptToolbar } from './ScriptToolbar';
-import { templates } from '../../templates';
 
-export const Default = {
-  args: {
-    binding: 'example',
-    deployed: true,
-    templates,
-    onFormat: () => console.log('Format'),
-    onTogglePanel: () => {},
-  },
-};
-
-const meta: Meta = {
+const meta = {
   title: 'plugins/plugin-script/Toolbar',
   component: ScriptToolbar,
-  decorators: [withTheme, withLayout()],
-};
+  // TODO(wittjosiah): Try to write story which does not depend on plugin manager.
+  decorators: [
+    withTheme,
+    withLayout({ classNames: 'is-prose' }),
+    withPluginManager({
+      plugins: [IntentPlugin(), ClientPlugin({})],
+    }),
+  ],
+  parameters: {
+    layout: 'centered',
+    translations,
+  },
+} satisfies Meta<typeof ScriptToolbar>;
 
 export default meta;
+
+type Story = StoryObj<typeof meta>;
+
+export const Default: Story = {
+  args: {
+    state: {},
+    script: Script.make({
+      name: 'test',
+      description: 'test',
+      source: 'test',
+    }),
+  },
+};

package/src/components/ScriptToolbar/ScriptToolbar.tsx

@@ -2,13 +2,20 @@
 // Copyright 2024 DXOS.org
 //
 
-import { Rx } from '@effect-rx/rx-react';
+import { Atom } from '@effect-atom/atom-react';
 import React, { useMemo } from 'react';
 
-import { type ScriptType } from '@dxos/functions';
-import { fullyQualifiedId } from '@dxos/react-client/echo';
-import { ElevationProvider, useTranslation, type ThemedClassName } from '@dxos/react-ui';
-import { createGapSeparator, MenuProvider, rxFromSignal, ToolbarMenu, useMenuActions } from '@dxos/react-ui-menu';
+import { Obj } from '@dxos/echo';
+import { type Script } from '@dxos/functions';
+import { ElevationProvider, useTranslation } from '@dxos/react-ui';
+import {
+  type ActionGraphProps,
+  MenuProvider,
+  ToolbarMenu,
+  atomFromSignal,
+  createGapSeparator,
+  useMenuActions,
+} from '@dxos/react-ui-menu';
 
 import {
   type CreateDeployOptions,
@@ -18,12 +25,33 @@ import {
   createTemplateSelect,
   useDeployDeps,
 } from '../../hooks';
-import { SCRIPT_PLUGIN } from '../../meta';
+import { meta } from '../../meta';
+
+export type ScriptToolbarProps = {
+  role?: string;
+  script: Script.Script;
+  state: ScriptToolbarState;
+};
+
+export const ScriptToolbar = ({ script, role, state }: ScriptToolbarProps) => {
+  const { t } = useTranslation(meta.id);
+  const options = useDeployDeps({ script });
+  const menu = useMemo(() => createToolbarActions({ state, script, t, ...options }), [state, script, options, t]);
+  const actions = useMenuActions(menu);
+
+  return (
+    <ElevationProvider elevation={role === 'section' ? 'positioned' : 'base'}>
+      <MenuProvider {...actions} attendableId={Obj.getDXN(script).toString()}>
+        <ToolbarMenu />
+      </MenuProvider>
+    </ElevationProvider>
+  );
+};
 
-const createToolbar = ({ state, script, ...options }: CreateDeployOptions) =>
-  Rx.make((get) =>
+const createToolbarActions = ({ state, script, ...options }: CreateDeployOptions): Atom.Atom<ActionGraphProps> =>
+  Atom.make((get) =>
     get(
-      rxFromSignal(() => {
+      atomFromSignal(() => {
         const templateSelect = createTemplateSelect(script);
         const format = createFormat(script);
         const gap = createGapSeparator();
@@ -35,24 +63,3 @@ const createToolbar = ({ state, script, ...options }: CreateDeployOptions) =>
       }),
     ),
   );
-
-export type ScriptToolbarProps = ThemedClassName<{
-  role?: string;
-  script: ScriptType;
-  state: ScriptToolbarState;
-}>;
-
-export const ScriptToolbar = ({ script, role, state, classNames }: ScriptToolbarProps) => {
-  const { t } = useTranslation(SCRIPT_PLUGIN);
-  const options = useDeployDeps({ script });
-  const toolbarCreator = useMemo(() => createToolbar({ state, script, t, ...options }), [state, script, options, t]);
-  const menu = useMenuActions(toolbarCreator);
-
-  return (
-    <ElevationProvider elevation={role === 'section' ? 'positioned' : 'base'}>
-      <MenuProvider {...menu} attendableId={fullyQualifiedId(script)}>
-        <ToolbarMenu classNames={classNames} />
-      </MenuProvider>
-    </ElevationProvider>
-  );
-};

package/src/components/Settings/ScriptObjectSettings.tsx

@@ -3,33 +3,40 @@
 //
 
 import { Octokit } from '@octokit/core';
-import React, { type ChangeEvent, useCallback, useEffect, useState } from 'react';
+import React, { type ChangeEvent, useCallback, useState } from 'react';
 
-import { createIntent, SettingsAction, useIntentDispatcher } from '@dxos/app-framework';
-import { FunctionType, type ScriptType, getInvocationUrl, getUserFunctionUrlInMetadata } from '@dxos/functions';
+import { ToolId } from '@dxos/ai';
+import { SettingsAction, createIntent } from '@dxos/app-framework';
+import { useIntentDispatcher } from '@dxos/app-framework/react';
+import { Blueprint, Template } from '@dxos/blueprints';
+import { Filter, Obj, Ref } from '@dxos/echo';
+import { Function, type Script, getUserFunctionIdInMetadata } from '@dxos/functions';
+import { getInvocationUrl } from '@dxos/functions-runtime';
 import { log } from '@dxos/log';
 import { useClient } from '@dxos/react-client';
-import { Filter, getMeta, getSpace, Ref, useQuery } from '@dxos/react-client/echo';
-import { Button, Clipboard, Input, useControlledState, useTranslation } from '@dxos/react-ui';
-import { DataType } from '@dxos/schema';
+import { getSpace, useQuery } from '@dxos/react-client/echo';
+import { Button, Clipboard, Input, useAsyncEffect, useControlledState, useTranslation } from '@dxos/react-ui';
+import { AccessToken } from '@dxos/types';
+import { kebabize } from '@dxos/util';
 
-import { SCRIPT_PLUGIN } from '../../meta';
+import { meta } from '../../meta';
 
 export type ScriptObjectSettingsProps = {
-  object: ScriptType;
+  object: Script.Script;
 };
 
 export const ScriptObjectSettings = ({ object }: ScriptObjectSettingsProps) => {
   return (
     <>
       <Binding object={object} />
+      <BlueprintEditor object={object} />
       <Publishing object={object} />
     </>
   );
 };
 
 export const ScriptProperties = ({ object }: ScriptObjectSettingsProps) => {
-  const { t } = useTranslation(SCRIPT_PLUGIN);
+  const { t } = useTranslation(meta.id);
   return (
     <Input.Root>
       <Input.Label>{t('description label')}</Input.Label>
@@ -44,16 +51,104 @@ export const ScriptProperties = ({ object }: ScriptObjectSettingsProps) => {
   );
 };
 
+const BlueprintEditor = ({ object }: ScriptObjectSettingsProps) => {
+  const { t } = useTranslation(meta.id);
+  const space = getSpace(object);
+  const [fn] = useQuery(space, Filter.type(Function.Function, { source: Ref.make(object) }));
+  const blueprints = useQuery(space, Filter.type(Blueprint.Blueprint));
+
+  const [creating, setCreating] = useState(false);
+  const [instructions, setInstructions] = useState<string>(`You can run the script "${object.name ?? 'script'}".`);
+  const blueprintKey = `dxos.org/blueprint/${kebabize(object.name ?? 'script')}`;
+  const existingBlueprint = blueprints.find((bp) => bp.key === blueprintKey);
+
+  useAsyncEffect(async () => {
+    if (!existingBlueprint) {
+      return;
+    }
+    const source = await existingBlueprint.instructions.source.load();
+    setInstructions(source.content ?? '');
+  }, [existingBlueprint]);
+
+  const handleSave = useCallback(async () => {
+    if (!space) {
+      return;
+    }
+
+    setCreating(true);
+    try {
+      if (existingBlueprint) {
+        const text = await existingBlueprint.instructions.source.load();
+        text.content = instructions;
+        if (fn?.key) {
+          const toolId = ToolId.make(fn.key);
+          if (!existingBlueprint.tools?.includes(toolId)) {
+            existingBlueprint.tools = [...(existingBlueprint.tools ?? []), toolId];
+          }
+        }
+      } else if (fn?.key) {
+        space.db.add(
+          Blueprint.make({
+            key: blueprintKey,
+            name: object.name ?? 'Script',
+            instructions: Template.make({
+              source: instructions,
+            }),
+            tools: [ToolId.make(fn.key)],
+          }),
+        );
+      }
+      await space.db.flush();
+    } finally {
+      setCreating(false);
+    }
+  }, [space, existingBlueprint, fn, blueprintKey, object.name, instructions]);
+
+  return (
+    <div className='flex flex-col gap-4 mlb-cardSpacingBlock'>
+      <div>
+        <h2>{t('blueprint editor label', { default: 'Blueprint' })}</h2>
+        <p className='text-description text-sm'>
+          {t('blueprint editor description', {
+            default: 'Create a blueprint that exposes this script as a tool.',
+          })}
+        </p>
+      </div>
+      <Input.Root>
+        <div role='none' className='flex flex-col gap-1'>
+          <Input.Label>{t('blueprint instructions label', { default: 'Instructions' })}</Input.Label>
+          <Input.TextArea
+            placeholder={t('blueprint instructions placeholder', {
+              default: 'Describe how this tool should be used.',
+            })}
+            rows={6}
+            value={instructions}
+            onChange={(event) => setInstructions(event.target.value)}
+            classNames='resize-y'
+          />
+        </div>
+      </Input.Root>
+      <div className='flex justify-end gap-2'>
+        <Button disabled={(!existingBlueprint && !fn?.key) || creating} onClick={handleSave}>
+          {t(creating ? 'creating label' : 'create blueprint label', {
+            default: creating ? 'Creating…' : 'Create blueprint',
+          })}
+        </Button>
+      </div>
+    </div>
+  );
+};
+
 const Binding = ({ object }: ScriptObjectSettingsProps) => {
-  const { t } = useTranslation(SCRIPT_PLUGIN);
+  const { t } = useTranslation(meta.id);
   const client = useClient();
   const space = getSpace(object);
-  const [fn] = useQuery(space, Filter.type(FunctionType, { source: Ref.make(object) }));
+  const [fn] = useQuery(space, Filter.type(Function.Function, { source: Ref.make(object) }));
 
-  const functionPath = fn && getUserFunctionUrlInMetadata(getMeta(fn));
+  const functionId = fn && getUserFunctionIdInMetadata(Obj.getMeta(fn));
   const functionUrl =
-    functionPath &&
-    getInvocationUrl(functionPath, client.config.values.runtime?.services?.edge?.url ?? '', {
+    functionId &&
+    getInvocationUrl(functionId, client.config.values.runtime?.services?.edge?.url ?? '', {
       spaceId: space?.id,
     });
 
@@ -109,14 +204,14 @@ const Binding = ({ object }: ScriptObjectSettingsProps) => {
 
 // TODO(burdon): Move to separate tab?
 const Publishing = ({ object }: ScriptObjectSettingsProps) => {
-  const { t } = useTranslation(SCRIPT_PLUGIN);
+  const { t } = useTranslation(meta.id);
   const { dispatchPromise: dispatch } = useIntentDispatcher();
   const space = getSpace(object);
-  const [githubToken] = useQuery(space, Filter.type(DataType.AccessToken, { source: 'github.com' }));
-  const gistKey = getMeta(object).keys.find(({ source }) => source === 'github.com');
+  const [githubToken] = useQuery(space, Filter.type(AccessToken.AccessToken, { source: 'github.com' }));
+  const gistKey = Obj.getMeta(object).keys.find(({ source }) => source === 'github.com');
   const [gistUrl, setGistUrl] = useState<string | undefined>();
 
-  useEffect(() => {
+  useAsyncEffect(async () => {
     const token = githubToken?.token;
     const gistId = gistKey?.id;
     if (!token || !gistId) {
@@ -124,24 +219,25 @@ const Publishing = ({ object }: ScriptObjectSettingsProps) => {
       return;
     }
 
-    const timeout = setTimeout(async () => {
-      try {
-        const octokit = new Octokit({ auth: githubToken.token });
-        const response = await octokit.request('GET /gists/{gist_id}', {
-          gist_id: gistId,
-        });
-        setGistUrl(response.data.html_url);
-      } catch (err) {
-        log.catch(err);
-        setGistUrl(undefined);
-      }
-    });
-
-    return () => clearTimeout(timeout);
+    try {
+      const octokit = new Octokit({ auth: githubToken.token });
+      const response = await octokit.request('GET /gists/{gist_id}', {
+        gist_id: gistId,
+      });
+      setGistUrl(response.data.html_url);
+    } catch (err) {
+      log.catch(err);
+      setGistUrl(undefined);
+    }
   }, [githubToken, gistKey]);
 
   const handleOpenTokenManager = useCallback(
-    () => dispatch(createIntent(SettingsAction.Open, { plugin: 'dxos.org/plugin/token-manager' })),
+    () =>
+      dispatch(
+        createIntent(SettingsAction.Open, {
+          plugin: 'dxos.org/plugin/token-manager',
+        }),
+      ),
     [],
   );
 
@@ -155,7 +251,7 @@ const Publishing = ({ object }: ScriptObjectSettingsProps) => {
 
     try {
       // TODO(wittjosiah): Factor out to intent.
-      const meta = getMeta(object);
+      const meta = Obj.getMeta(object);
       const githubKey = meta.keys.find(({ source }) => source === 'github.com');
       const gistId = githubKey?.id;
       if (gistId) {
@@ -200,7 +296,3 @@ const Publishing = ({ object }: ScriptObjectSettingsProps) => {
     </div>
   );
 };
-
-// TODO(wittjosiah): Factor out.
-// From https://stackoverflow.com/a/67243723/2804332
-const kebabize = (str: string) => str.replace(/[A-Z]+(?![a-z])|[A-Z]/g, ($, ofs) => (ofs ? '-' : '') + $.toLowerCase());