@dxos/plugin-script 0.8.4-main.c4373fc → 0.8.4-main.d9fc60f731

package/src/components/index.ts

@@ -2,14 +2,12 @@
 // Copyright 2023 DXOS.org
 //
 
-import { lazy } from 'react';
+import { type ComponentType, lazy } from 'react';
 
 export * from './NotebookStack';
-export * from './Settings';
+export * from './QueryEditor';
+export * from './ScriptToolbar';
 export * from './TestPanel';
+export * from './TypescriptEditor';
 
-export { DEPLOYMENT_DIALOG } from './DeploymentDialog';
-
-export const ScriptContainer = lazy(() => import('./ScriptContainer'));
-export const DeploymentDialog = lazy(() => import('./DeploymentDialog'));
-export const NotebookContainer = lazy(() => import('./NotebookContainer'));
+export const ScriptPluginSettings: ComponentType<any> = lazy(() => import('./ScriptPluginSettings'));

package/src/constants.ts

@@ -0,0 +1,9 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { DXN } from '@dxos/keys';
+
+import { meta } from '#meta';
+
+export const DEPLOYMENT_DIALOG = DXN.make(`${meta.id}.deploymentDialog`);

package/src/containers/DeploymentDialog/DeploymentDialog.stories.tsx

@@ -0,0 +1,63 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import { type Meta, type StoryObj } from '@storybook/react-vite';
+import React, { useMemo } from 'react';
+
+import { ProcessManagerPlugin } from '@dxos/app-framework';
+import { withPluginManager } from '@dxos/app-framework/testing';
+import { Obj } from '@dxos/echo';
+import { ClientPlugin } from '@dxos/plugin-client/testing';
+import { Dialog } from '@dxos/react-ui';
+import { withTheme } from '@dxos/react-ui/testing';
+import { AccessToken } from '@dxos/types';
+
+import { translations } from '#translations';
+
+import { DeploymentDialog } from './DeploymentDialog';
+
+const DeploymentDialogStory = () => {
+  const accessToken = useMemo(
+    () =>
+      Obj.make(AccessToken.AccessToken, {
+        source: 'example.com',
+        token: 'example-token',
+      }),
+    [],
+  );
+  const scriptTemplates = useMemo(
+    () => [
+      { id: 't-1', name: 'Script 1', source: 'template1' },
+      { id: 't-2', name: 'Script 2', source: 'template2' },
+      { id: 't-3', name: 'Script 3', source: 'template3' },
+    ],
+    [],
+  );
+  return (
+    <Dialog.Root defaultOpen={true}>
+      <Dialog.Overlay>
+        <DeploymentDialog accessToken={accessToken} scriptTemplates={scriptTemplates} />
+      </Dialog.Overlay>
+    </Dialog.Root>
+  );
+};
+
+const meta = {
+  title: 'plugins/plugin-script/containers/DeploymentDialog',
+  component: DeploymentDialogStory,
+  parameters: { translations },
+  // TODO(wittjosiah): Try to write story which does not depend on plugin manager.
+  decorators: [
+    withTheme(),
+    withPluginManager({
+      plugins: [ProcessManagerPlugin(), ClientPlugin({})],
+    }),
+  ],
+} satisfies Meta<typeof DeploymentDialogStory>;
+
+export default meta;
+
+type Story = StoryObj<typeof meta>;
+
+export const Default: Story = {};

package/src/containers/DeploymentDialog/DeploymentDialog.tsx

@@ -0,0 +1,99 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import React, { useEffect, useMemo } from 'react';
+
+import { useOperationInvoker } from '@dxos/app-framework/ui';
+import { LayoutOperation } from '@dxos/app-toolkit';
+import { getSpace } from '@dxos/react-client/echo';
+import { Button, Dialog, useTranslation } from '@dxos/react-ui';
+import { type AccessToken } from '@dxos/types';
+
+import { useCreateAndDeployScriptTemplates } from '#hooks';
+import { meta } from '#meta';
+
+import { type Template } from '../../templates';
+
+// TODO(ZaymonFC):
+//  - Show activity and feedback to the user.
+//  - Only take an array of templateIds and get the name from the data.
+//  - Pending / onError states.
+
+export type DeploymentDialogProps = {
+  accessToken: AccessToken.AccessToken;
+  scriptTemplates: Template[];
+};
+
+export const DeploymentDialog = ({ accessToken, scriptTemplates }: DeploymentDialogProps) => {
+  const { t } = useTranslation(meta.id);
+  const space = useMemo(() => getSpace(accessToken), [accessToken]);
+
+  // TODO(ZaymonFC): Thinking further. All of this should get moved to intents to run async in the background.
+  //   Deployment shouldn't be tied to the lifecycle of the dialogue component.
+  const { handleCreateAndDeployScripts, status } = useCreateAndDeployScriptTemplates(space, scriptTemplates);
+  const { invokePromise } = useOperationInvoker();
+
+  useEffect(() => {
+    if (status === 'success') {
+      // TODO(ZaymonFC): We can probably re-use this toast for normal script deployment.
+      void invokePromise(LayoutOperation.AddToast, {
+        id: `${meta.id}.deployment-success`,
+        icon: 'ph--check--regular',
+        duration: Infinity,
+        title: ['script-deployment-toast.label', { ns: meta.id, count: scriptTemplates.length }],
+        description: ['script-deployment-toast.description', { ns: meta.id, count: scriptTemplates.length }],
+        closeLabel: ['script-deployment-toast-close.label', { ns: meta.id, count: scriptTemplates.length }],
+      });
+      void invokePromise(LayoutOperation.UpdateDialog, { state: false });
+    }
+    if (status === 'error') {
+      void invokePromise(LayoutOperation.UpdateDialog, { state: false });
+      void invokePromise(LayoutOperation.AddToast, {
+        id: `${meta.id}.deployment-error`,
+        icon: 'ph--warning--regular',
+        duration: Infinity,
+        title: ['script-deployment-error-toast.label', { ns: meta.id, count: scriptTemplates.length }],
+        description: ['script-deployment-error-toast.description', { ns: meta.id, count: scriptTemplates.length }],
+        closeLabel: ['script-deployment-error-toast-close.label', { ns: meta.id, count: scriptTemplates.length }],
+      });
+    }
+  }, [status, invokePromise]);
+
+  return (
+    <Dialog.Content>
+      <Dialog.Header>
+        <Dialog.Title>{t('deployment-dialog.title')}</Dialog.Title>
+        <Dialog.Close asChild>
+          <Dialog.ActionIconButton action='close' />
+        </Dialog.Close>
+      </Dialog.Header>
+      <Dialog.Body>
+        <p>
+          {t('deployment-dialog-scripts-found.message', {
+            count: scriptTemplates.length,
+          })}
+        </p>
+        <ul className='pt-2'>
+          {scriptTemplates.map((template) => {
+            return <li key={template.id}>{template.name}</li>;
+          })}
+        </ul>
+      </Dialog.Body>
+      <Dialog.ActionBar>
+        <Dialog.Close asChild>
+          <Button disabled={status === 'pending'}>{t('deployment-dialog-skip-button.label')}</Button>
+        </Dialog.Close>
+        <Button variant='primary' onClick={handleCreateAndDeployScripts} disabled={status === 'pending'}>
+          {status === 'pending'
+            ? t('deployment-dialog-deploy-functions-pending-button.label', {
+                count: scriptTemplates.length,
+              })
+            : t('deployment-dialog-deploy-functions-button.label', {
+                count: scriptTemplates.length,
+              })}
+        </Button>
+      </Dialog.ActionBar>
+    </Dialog.Content>
+  );
+};

package/src/containers/DeploymentDialog/index.ts

@@ -0,0 +1,5 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+export { DeploymentDialog as default } from './DeploymentDialog';

package/src/containers/NotebookArticle/NotebookArticle.stories.tsx

@@ -0,0 +1,85 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import { type Meta, type StoryObj } from '@storybook/react-vite';
+import * as Effect from 'effect/Effect';
+import React from 'react';
+
+import { SERVICES_CONFIG } from '@dxos/ai/testing';
+import { withPluginManager } from '@dxos/app-framework/testing';
+import { AgentPrompt } from '@dxos/assistant-toolkit';
+import { Operation } from '@dxos/compute';
+import { Filter } from '@dxos/echo';
+import { AssistantPlugin } from '@dxos/plugin-assistant/testing';
+import { AutomationPlugin } from '@dxos/plugin-automation/testing';
+import { ClientPlugin } from '@dxos/plugin-client/testing';
+import { initializeIdentity } from '@dxos/plugin-client/testing';
+import { ExplorerPlugin } from '@dxos/plugin-explorer/testing';
+import { Markdown } from '@dxos/plugin-markdown';
+import { MarkdownPlugin } from '@dxos/plugin-markdown/testing';
+import { corePlugins } from '@dxos/plugin-testing';
+import { Config, useClient } from '@dxos/react-client';
+import { useQuery } from '@dxos/react-client/echo';
+import { withLayout } from '@dxos/react-ui/testing';
+import { DataTypes } from '@dxos/schema';
+
+import { createNotebook } from '#testing';
+import { translations } from '#translations';
+import { Notebook } from '#types';
+
+import { NotebookArticle } from './NotebookArticle';
+
+const meta: Meta<typeof NotebookArticle> = {
+  title: 'plugins/plugin-script/containers/NotebookArticle',
+  component: NotebookArticle,
+  render: (args) => {
+    const client = useClient();
+    const space = client.spaces.get()[0];
+    const notebooks = useQuery(space?.db, Filter.type(Notebook.Notebook));
+    return <NotebookArticle {...args} subject={notebooks[0]} attendableId='test' />;
+  },
+  decorators: [
+    withLayout({ layout: 'column', classNames: 'w-document-max-width' }),
+    withPluginManager({
+      plugins: [
+        ...corePlugins(),
+        ClientPlugin({
+          // TODO(wittjosiah): ComputeRuntime requires edge to be configured or it will throw.
+          config: new Config({
+            runtime: {
+              services: SERVICES_CONFIG.REMOTE,
+            },
+          }),
+          types: [...DataTypes, Notebook.Notebook, Operation.PersistentOperation, Markdown.Document],
+          onClientInitialized: ({ client }) =>
+            Effect.gen(function* () {
+              const { personalSpace } = yield* initializeIdentity(client);
+
+              personalSpace.db.add(createNotebook());
+              personalSpace.db.add(Markdown.make({ content: '# Hello World' }));
+              personalSpace.db.add(Operation.serialize(AgentPrompt));
+            }),
+        }),
+        AssistantPlugin(),
+        AutomationPlugin(),
+        ExplorerPlugin(),
+        MarkdownPlugin(),
+      ],
+    }),
+  ],
+  parameters: {
+    translations,
+  },
+};
+
+export default meta;
+
+type Story = StoryObj<typeof meta>;
+
+export const Default: Story = {
+  args: {
+    role: 'article',
+    subject: undefined as any,
+  },
+};

package/src/containers/NotebookArticle/NotebookArticle.tsx

@@ -0,0 +1,255 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { RegistryContext } from '@effect-atom/atom-react';
+import * as Cause from 'effect/Cause';
+import * as Effect from 'effect/Effect';
+import * as Exit from 'effect/Exit';
+import type * as Types from 'effect/Types';
+import React, { useCallback, useContext, useMemo, useState } from 'react';
+
+import { useSpaceCallback } from '@dxos/app-framework/ui';
+import { type AppSurface } from '@dxos/app-toolkit/ui';
+import { AgentPrompt } from '@dxos/assistant-toolkit';
+import { Blueprint, Routine } from '@dxos/compute';
+import { Operation } from '@dxos/compute';
+import { Filter, Obj, Query, Ref } from '@dxos/echo';
+import { QueryBuilder } from '@dxos/echo-query';
+import { invariant } from '@dxos/invariant';
+import { log } from '@dxos/log';
+import { Graph } from '@dxos/plugin-explorer';
+import { DropdownMenu, IconButton, Panel, Toolbar, useTranslation } from '@dxos/react-ui';
+import { useAttention } from '@dxos/react-ui-attention';
+import { Text, ViewModel } from '@dxos/schema';
+import { isNonNullable } from '@dxos/util';
+
+import { NotebookMenu, NotebookStack, type NotebookStackProps, type TypescriptEditorProps } from '#components';
+import { meta } from '#meta';
+import { type Notebook } from '#types';
+
+import { ComputeGraph } from '../../notebook';
+
+const INCLUDE_BLUEPRINTS = [
+  'org.dxos.blueprint.assistant',
+  'org.dxos.blueprint.database',
+  'org.dxos.blueprint.markdown',
+];
+
+// TODO(burdon): Support calling named deployed functions (as with sheet).
+
+export type NotebookArticleProps = AppSurface.ObjectArticleProps<Notebook.Notebook, Pick<TypescriptEditorProps, 'env'>>;
+
+export const NotebookArticle = ({ role, subject: notebook, attendableId, env }: NotebookArticleProps) => {
+  const { t } = useTranslation(meta.id);
+  const registry = useContext(RegistryContext);
+  const db = Obj.getDatabase(notebook);
+  const { hasAttention } = useAttention(attendableId);
+
+  // TODO(burdon): Consolidate execution and state (with graph).
+  //  Generalize ComputeGraph evaluation function (using effects).
+  const graph = useMemo(() => notebook && new ComputeGraph(notebook, registry), [notebook, registry]);
+
+  const [queryValues, setQueryValues] = useState<Record<string, any>>({});
+  const handleExecQueries = useCallback(async () => {
+    invariant(db);
+
+    const builder = new QueryBuilder();
+    for (const cell of notebook?.cells ?? []) {
+      if (cell.type === 'query') {
+        if (cell.source?.target) {
+          const source = cell.source.target.content;
+          const { name, filter } = builder.build(source);
+          if (filter) {
+            const ast = Query.select(filter).ast;
+            const graph = cell.graph?.target;
+            if (!graph) {
+              const { view } = await ViewModel.makeFromDatabase({ db });
+              const newGraph = Graph.make({ query: { ast }, view });
+              Obj.update(notebook!, (obj) => {
+                const c = obj.cells.find((c) => c.id === cell.id);
+                if (c) {
+                  c.graph = Ref.make(newGraph);
+                  c.name = name;
+                }
+              });
+            } else {
+              Obj.update(graph, (graph) => {
+                graph.query.ast = ast as Obj.Mutable<typeof ast>;
+              });
+            }
+          }
+        }
+
+        if (cell.name && cell.graph?.target) {
+          const graph = Obj.getSnapshot(cell.graph?.target);
+          const query = Query.fromAst(graph.query.ast);
+          const objects = await db.query(query).run();
+          const objectIds = objects?.map((obj) => obj.id);
+          setQueryValues((prev) => ({ ...prev, [cell.name!]: objectIds }));
+        }
+      }
+    }
+  }, [db, notebook, graph]);
+
+  const [promptResults, setPromptResults] = useState<Record<string, string>>({});
+  const handleExecPrompts = useSpaceCallback(
+    db?.spaceId,
+    [] as const,
+    Effect.fnUntraced(function* () {
+      invariant(graph);
+
+      const prompts =
+        notebook?.cells
+          .filter((cell) => cell.type === 'prompt')
+          .map((cell) => cell.prompt)
+          .filter(isNonNullable) ?? [];
+
+      for (const prompt of prompts) {
+        yield* runPrompt({
+          prompt,
+          input: { ...queryValues, ...graph.getValuesByName() },
+          onResult: (result) =>
+            setPromptResults((prev) => ({
+              ...prev,
+              [prompt.uri]: result,
+            })),
+        });
+      }
+    }),
+    [notebook, graph, queryValues],
+  );
+
+  // TODO(burdon): Cache values in context (preserve when switched).
+  const handleCompute = useCallback(async () => {
+    // TODO(burdon): Generalize executors (dependencies).
+    await graph?.evaluate();
+    await handleExecQueries();
+    await handleExecPrompts();
+  }, [graph, handleExecQueries, handleExecPrompts]);
+
+  const handleRearrange = useCallback<NonNullable<NotebookStackProps['onRearrange']>>(
+    (source, target) => {
+      invariant(notebook);
+      const from = notebook.cells.findIndex((cell) => cell.id === source.id);
+      const to = notebook.cells.findIndex((cell) => cell.id === target.id);
+      if (from != null && to != null) {
+        Obj.update(notebook, (notebook) => {
+          const cell = notebook.cells.splice(from, 1)[0];
+          if (cell) {
+            notebook.cells.splice(to, 0, cell);
+          }
+        });
+      }
+    },
+    [notebook],
+  );
+
+  const handleCellInsert = useCallback<NonNullable<NotebookStackProps['onCellInsert']>>(
+    async (type, after) => {
+      invariant(notebook);
+      const cell: Types.Mutable<Notebook.Cell> = { id: crypto.randomUUID(), type };
+      switch (type) {
+        case 'markdown':
+        case 'script':
+        case 'query': {
+          cell.source = Ref.make(Text.make());
+          break;
+        }
+
+        case 'prompt': {
+          if (db) {
+            const objects = await db.query(Query.select(Filter.type(Blueprint.Blueprint))).run();
+            const blueprints = objects
+              .filter((blueprint) => {
+                const key = Obj.getMeta(blueprint).key;
+                return key !== undefined && INCLUDE_BLUEPRINTS.includes(key);
+              })
+              .map((blueprint) => Ref.make(blueprint));
+            cell.prompt = Ref.make(Routine.make({ instructions: '', blueprints }));
+          }
+          break;
+        }
+      }
+
+      const idx = after ? notebook.cells.findIndex((cell) => cell.id === after) : notebook.cells.length;
+      Obj.update(notebook, (notebook) => {
+        notebook.cells.splice(idx, 0, cell);
+      });
+    },
+    [db, notebook],
+  );
+
+  const handleCellDelete = useCallback<NonNullable<NotebookStackProps['onCellDelete']>>(
+    (id) => {
+      invariant(notebook);
+      const idx = notebook.cells.findIndex((cell) => cell.id === id);
+      if (idx !== -1) {
+        Obj.update(notebook, (notebook) => {
+          notebook.cells.splice(idx, 1);
+        });
+      }
+    },
+    [notebook],
+  );
+
+  return (
+    <Panel.Root role={role} className='dx-document'>
+      <Panel.Toolbar asChild>
+        <Toolbar.Root disabled={!hasAttention}>
+          <DropdownMenu.Root>
+            <DropdownMenu.Trigger asChild>
+              <IconButton icon='ph--plus--regular' iconOnly label={t('notebook-cell-insert.label')} />
+            </DropdownMenu.Trigger>
+            <NotebookMenu onCellInsert={handleCellInsert} />
+          </DropdownMenu.Root>
+          <Toolbar.IconButton
+            icon='ph--play--fill'
+            iconOnly
+            label={t('compute.label')}
+            classNames='text-success-text'
+            onClick={handleCompute}
+          />
+        </Toolbar.Root>
+      </Panel.Toolbar>
+      <Panel.Content asChild>
+        <NotebookStack
+          db={db}
+          notebook={notebook}
+          graph={graph}
+          env={env}
+          promptResults={promptResults}
+          onRearrange={handleRearrange}
+          onCellInsert={handleCellInsert}
+          onCellDelete={handleCellDelete}
+        />
+      </Panel.Content>
+    </Panel.Root>
+  );
+};
+
+// TODO(wittjosiah): Factor out. Copied from PromptArticle in plugin-assistant.
+const runPrompt = Effect.fn(function* ({
+  prompt,
+  input,
+  onResult,
+}: {
+  prompt: Ref.Ref<Routine.Routine>;
+  input: Record<string, any>;
+  onResult: (result: string) => void;
+}) {
+  const inputData: Operation.Definition.Input<typeof AgentPrompt> = { prompt, input };
+  // Invoke the function.
+  const result = yield* Operation.invoke(AgentPrompt, inputData).pipe(Effect.orDie, Effect.exit);
+
+  Exit.match(result, {
+    onFailure: (cause) => {
+      const error = Cause.prettyErrors(cause)[0];
+      log.error(error.message, error.cause ?? error.stack);
+      onResult(error.message);
+    },
+    onSuccess: (result: any) => {
+      onResult(result.note);
+    },
+  });
+});

package/src/containers/NotebookArticle/index.ts

@@ -0,0 +1,5 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+export { NotebookArticle as default } from './NotebookArticle';

package/src/containers/ScriptArticle/ScriptArticle.stories.tsx

@@ -0,0 +1,107 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { type Meta, type StoryObj } from '@storybook/react-vite';
+import * as Effect from 'effect/Effect';
+import React, { useEffect, useState } from 'react';
+
+import { SERVICES_CONFIG } from '@dxos/ai/testing';
+import { withPluginManager } from '@dxos/app-framework/testing';
+import { Blueprint } from '@dxos/compute';
+import { Script } from '@dxos/compute';
+import { Operation } from '@dxos/compute';
+import { Filter } from '@dxos/echo';
+import { ClientPlugin } from '@dxos/plugin-client/testing';
+import { initializeIdentity } from '@dxos/plugin-client/testing';
+import { StorybookPlugin, corePlugins } from '@dxos/plugin-testing';
+import { Config } from '@dxos/react-client';
+import { useQuery, useSpaces } from '@dxos/react-client/echo';
+import { Loading, withLayout, withTheme } from '@dxos/react-ui/testing';
+import { Text } from '@dxos/schema';
+
+import { createScript } from '#testing';
+import { translations } from '#translations';
+
+import { ScriptArticle } from './ScriptArticle';
+
+type DefaultStoryProps = {};
+
+/**
+ * Loads the script source ref so `script.source.target` is available for the editor.
+ */
+const DefaultStory = (_: DefaultStoryProps) => {
+  const [space] = useSpaces();
+  const [script] = useQuery(space?.db, Filter.type(Script.Script));
+  const [sourceReady, setSourceReady] = useState(false);
+
+  useEffect(() => {
+    if (!script) {
+      setSourceReady(false);
+      return;
+    }
+
+    let canceled = false;
+    void (async () => {
+      await script.source.load();
+      if (!canceled) {
+        setSourceReady(true);
+      }
+    })();
+
+    return () => {
+      canceled = true;
+    };
+  }, [script]);
+
+  if (!script || !sourceReady) {
+    return <Loading />;
+  }
+
+  return (
+    <div className='flex flex-col min-h-[80vh] w-document-max-width'>
+      <ScriptArticle role='article' subject={script} attendableId='story-script' />
+    </div>
+  );
+};
+
+const meta = {
+  title: 'plugins/plugin-script/containers/ScriptArticle',
+  render: DefaultStory,
+  decorators: [
+    withTheme(),
+    withLayout({ layout: 'column', classNames: 'w-document-max-width' }),
+    withPluginManager({
+      plugins: [
+        ...corePlugins(),
+        ClientPlugin({
+          config: new Config({
+            runtime: {
+              services: SERVICES_CONFIG.REMOTE,
+            },
+          }),
+          types: [Script.Script, Operation.PersistentOperation, Blueprint.Blueprint, Text.Text],
+          onClientInitialized: ({ client }) =>
+            Effect.gen(function* () {
+              yield* initializeIdentity(client);
+              const [space] = client.spaces.get();
+              yield* Effect.promise(() => space.waitUntilReady());
+
+              createScript(space);
+            }),
+        }),
+        StorybookPlugin({}),
+      ],
+    }),
+  ],
+  parameters: {
+    layout: 'fullscreen',
+    translations,
+  },
+} satisfies Meta<DefaultStoryProps>;
+
+export default meta;
+
+type Story = StoryObj<typeof meta>;
+
+export const Default: Story = {};