@dxos/plugin-script 0.8.4-main.406dc2a → 0.8.4-main.4f23b4e393

package/src/hooks/template.ts

@@ -2,37 +2,35 @@
 // Copyright 2025 DXOS.org
 //
 
+import { Script } from '@dxos/compute';
 import { Obj } from '@dxos/echo';
-import { FUNCTIONS_PRESET_META_KEY, type ScriptType } from '@dxos/functions';
-import { createMenuAction, createMenuItemGroup } from '@dxos/react-ui-menu';
+import { FUNCTIONS_PRESET_META_KEY } from '@dxos/functions';
+import { createMenuAction } from '@dxos/react-ui-menu';
 
-import { meta } from '../meta';
 import { templates } from '../templates';
 
 export type TemplateActionProperties = { type: 'template'; value: string };
 
-const createTemplateSelectGroup = () => {
-  // TODO(burdon): This should not be in the toolbar (move to create Object dialog).
-  return createMenuItemGroup('template-select', {
-    label: ['template select group label', { ns: meta.id }],
-    variant: 'dropdownMenu',
-  });
-};
-
-const createTemplateSelectActions = (script: ScriptType) => {
+const createTemplateSelectActions = (script: Script.Script) => {
   return templates.map((template) => {
     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.update(script, (script) => {
+          script.name = template.name;
+          const meta = Obj.getMeta(script);
+          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.update(script.source.target, (obj) => {
+            obj.content = template.source;
+          });
         }
       },
       {
@@ -44,14 +42,13 @@ const createTemplateSelectActions = (script: ScriptType) => {
   });
 };
 
-export const createTemplateSelect = (script: ScriptType) => {
-  const templateSelectGroup = createTemplateSelectGroup();
+export const createTemplateSelect = (script: Script.Script) => {
   const templateSelectActions = createTemplateSelectActions(script);
   return {
-    nodes: [templateSelectGroup, ...templateSelectActions],
+    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,25 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { useCapabilities, usePluginManager } from '@dxos/app-framework/ui';
+import { runAndForwardErrors } from '@dxos/effect';
+import { useAsyncEffect } from '@dxos/react-ui';
+
+import { ScriptEvents } from '#types';
+import { ScriptCapabilities } from '#types';
+
+import type { Compiler } from '../compiler';
+
+/**
+ * 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;
+};

package/src/hooks/useCreateAndDeployScriptTemplates.ts

@@ -2,19 +2,19 @@
 // Copyright 2025 DXOS.org
 //
 
-import * as Function from 'effect/Function';
 import { useCallback, useState } from 'react';
 
-import { chain, createIntent, useIntentDispatcher } from '@dxos/app-framework';
+import { useOperationInvoker } from '@dxos/app-framework/ui';
+import { Script } from '@dxos/compute';
 import { Obj } from '@dxos/echo';
-import { ScriptType } from '@dxos/functions';
 import { invariant } from '@dxos/invariant';
-import { SpaceAction } from '@dxos/plugin-space/types';
+import { SpaceOperation } from '@dxos/plugin-space';
 import { useClient } from '@dxos/react-client';
 import { type Space } from '@dxos/react-client/echo';
 
+import { ScriptOperation } from '#types';
+
 import { type Template } from '../templates';
-import { ScriptAction } from '../types';
 import { deployScript } from '../util';
 
 type DeploymentStatus = 'idle' | 'pending' | 'success' | 'error';
@@ -27,7 +27,7 @@ type DeploymentStatus = 'idle' | 'pending' | 'success' | 'error';
  * All creation / deployment operations run concurrently for improved performance.
  */
 export const useCreateAndDeployScriptTemplates = (space: Space | undefined, scriptTemplates: Template[]) => {
-  const { dispatchPromise: dispatch } = useIntentDispatcher();
+  const { invokePromise } = useOperationInvoker();
   const client = useClient();
   const [status, setStatus] = useState<DeploymentStatus>('idle');
   const [error, setError] = useState<Error | undefined>(undefined);
@@ -39,21 +39,20 @@ export const useCreateAndDeployScriptTemplates = (space: Space | undefined, scri
 
     const deploymentResults = await Promise.all(
       scriptTemplates.map(async (template) => {
-        const result = await dispatch(
-          Function.pipe(
-            createIntent(ScriptAction.CreateScript, { space, initialTemplateId: template.id as any }),
-            chain(SpaceAction.AddObject, { target: space }),
-          ),
-        );
-        invariant(Obj.instanceOf(ScriptType, result.data?.object));
-
-        return deployScript({ space, client, script: result.data.object });
+        const createResult = await invokePromise(ScriptOperation.CreateScript, {
+          db: space.db,
+          initialTemplateId: template.id as any,
+        });
+        invariant(Obj.instanceOf(Script.Script, createResult.data?.object));
+        await invokePromise(SpaceOperation.AddObject, { target: space.db, object: createResult.data.object });
+
+        return deployScript({ space, client, script: createResult.data.object });
       }),
     );
 
     const hasErrors = deploymentResults.some((result) => !result.success);
     setStatus(hasErrors ? 'error' : 'success');
-  }, [space, dispatch, client, scriptTemplates]);
+  }, [space, invokePromise, client, scriptTemplates]);
 
   // TODO(burdon): Return onCreateAndDeployScripts.
   return { handleCreateAndDeployScripts, status, error };

package/src/hooks/useToolbarState.ts

@@ -2,15 +2,40 @@
 // Copyright 2025 DXOS.org
 //
 
+import { Atom } from '@effect-atom/atom-react';
 import { useMemo } from 'react';
 
-import { live } from '@dxos/live-object';
+import { Capabilities } from '@dxos/app-framework';
+import { useCapability } from '@dxos/app-framework/ui';
 
 import { type DeployState } from './deploy';
 
 export type ScriptToolbarState = Partial<DeployState>;
 
-// TODO(burdon): Replace with context provider?
-export const useToolbarState = (initialState: ScriptToolbarState = {}) => {
-  return useMemo(() => live<ScriptToolbarState>(initialState), []);
+export type ScriptToolbarStateStore = {
+  atom: Atom.Writable<ScriptToolbarState>;
+  get value(): ScriptToolbarState;
+  update: (updater: (current: ScriptToolbarState) => ScriptToolbarState) => void;
+  set: <K extends keyof ScriptToolbarState>(key: K, value: ScriptToolbarState[K]) => void;
+};
+
+export const useToolbarState = (initialState: ScriptToolbarState = {}): ScriptToolbarStateStore => {
+  const registry = useCapability(Capabilities.AtomRegistry);
+  const atom = useMemo(() => Atom.make<ScriptToolbarState>(initialState), []);
+
+  return useMemo(
+    () => ({
+      atom,
+      get value() {
+        return registry.get(atom);
+      },
+      update: (updater: (current: ScriptToolbarState) => ScriptToolbarState) => {
+        registry.set(atom, updater(registry.get(atom)));
+      },
+      set: <K extends keyof ScriptToolbarState>(key: K, v: ScriptToolbarState[K]) => {
+        registry.set(atom, { ...registry.get(atom), [key]: v });
+      },
+    }),
+    [atom, registry],
+  );
 };

package/src/index.ts

@@ -2,9 +2,7 @@
 // Copyright 2023 DXOS.org
 //
 
-export { ScriptCapabilities } from './capabilities';
-export * from './components';
+export * from './blueprints';
 export * from './meta';
+export * from './types';
 export * from './util';
-
-export * from './ScriptPlugin';

package/src/meta.ts

@@ -2,14 +2,18 @@
 // Copyright 2023 DXOS.org
 //
 
-import { type PluginMeta } from '@dxos/app-framework';
+import { type Plugin } from '@dxos/app-framework';
+import { trim } from '@dxos/util';
 
-export const meta: PluginMeta = {
-  id: 'dxos.org/plugin/script',
+export const meta: Plugin.Meta = {
+  id: 'org.dxos.plugin.script',
   name: 'Scripts',
-  description:
-    'Scripts enable you to deploy custom functions that run on the edge. These functions can be referenced by your AI agent and called inside of cells in any Sheet. Use scripts to interact with API’s or external data inside of Composer.',
+  description: trim`
+    Write and deploy custom JavaScript functions that extend your workspace capabilities.
+    Create AI agent tools, spreadsheet formulas, and automation scripts that integrate seamlessly with other plugins.
+  `,
   icon: 'ph--code--regular',
+  iconHue: 'sky',
   source: 'https://github.com/dxos/dxos/tree/main/packages/plugins/plugin-explorer',
   tags: ['labs'],
   screenshots: ['https://dxos.network/plugin-details-scripts-dark.png'],
@@ -18,5 +22,5 @@ export const meta: PluginMeta = {
 // TODO(ZaymonFC): Configure by scopes?
 export const defaultScriptsForIntegration: Record<string, string[]> = {
   // TODO(wittjosiah): Also include content extraction scripts in the default set.
-  'gmail.com': ['dxos.org/script/gmail'],
+  'gmail.com': ['org.dxos.script.gmail'],
 };

package/src/notebook/compute-graph.test.ts

@@ -0,0 +1,82 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Registry } from '@effect-atom/atom-react';
+import { describe, expect, test } from 'vitest';
+
+import { Obj } from '@dxos/echo';
+
+import { createNotebook } from '#testing';
+
+import { ComputeGraph } from './compute-graph';
+
+describe('notebook', () => {
+  test('parse dependency graph', async () => {
+    const registry = Registry.make();
+    const notebook = createNotebook();
+    const graph = new ComputeGraph(notebook, registry);
+    const result = graph.parse();
+
+    const getId = (i: number) => notebook.cells[i].id;
+
+    // Check dependencies.
+    expect(result.dependencyGraph).toMatchObject({
+      [getId(0)]: [getId(1), getId(2)],
+      [getId(3)]: [getId(1)],
+      [getId(4)]: [getId(0), getId(3)],
+    });
+
+    // Compute values.
+    const values = await graph.evaluate();
+    expect(values).toEqual({
+      [getId(0)]: 300,
+      [getId(2)]: 200,
+      [getId(3)]: 200,
+      [getId(4)]: 500,
+    });
+  });
+
+  test('evalScript blocks access to window and document', async () => {
+    const registry = Registry.make();
+    const notebook = createNotebook();
+    // Replace one of the cells with code that tries to access window/document.
+    const sourceTarget = notebook.cells[2].source?.target;
+    if (sourceTarget) {
+      Obj.update(sourceTarget, (sourceTarget) => {
+        sourceTarget.content = 'b = typeof window';
+      });
+    }
+
+    const graph = new ComputeGraph(notebook, registry);
+    graph.parse();
+    const values = await graph.evaluate();
+
+    // Should evaluate to 'undefined' since window is blocked.
+    expect(values[notebook.cells[2].id]).toBe('undefined');
+
+    // Test document access.
+    if (sourceTarget) {
+      Obj.update(sourceTarget, (sourceTarget) => {
+        sourceTarget.content = 'b = typeof document';
+      });
+    }
+    graph.parse();
+    const values2 = await graph.evaluate();
+
+    // Should evaluate to 'undefined' since document is blocked.
+    expect(values2[notebook.cells[2].id]).toBe('undefined');
+
+    // Test that safe globals still work.
+    if (sourceTarget) {
+      Obj.update(sourceTarget, (sourceTarget) => {
+        sourceTarget.content = 'b = Math.max(100, 200)';
+      });
+    }
+    graph.parse();
+    const values3 = await graph.evaluate();
+
+    // Should evaluate correctly.
+    expect(values3[notebook.cells[2].id]).toBe(200);
+  });
+});

package/src/notebook/{notebook.ts → compute-graph.ts}

@@ -2,11 +2,11 @@
 // Copyright 2025 DXOS.org
 //
 
-import { type Signal, signal } from '@preact/signals-core';
+import { Atom, type Registry } from '@effect-atom/atom-react';
 
 import { log } from '@dxos/log';
 
-import { type Notebook } from '../types';
+import { type Notebook } from '#types';
 
 import { evalScript } from './eval';
 import { type ParsedExpression, VirtualTypeScriptParser } from './vfs-parser';
@@ -14,35 +14,76 @@ import { type ParsedExpression, VirtualTypeScriptParser } from './vfs-parser';
 /**
  * Compute graph that evaluates the notebook cells.
  */
+// TODO(burdon): Reconcile with @dxos/conductor.
 export class ComputeGraph {
   private readonly _parser = new VirtualTypeScriptParser();
 
-  private _expressions = signal<Record<string, ParsedExpression>>({});
-  private _values = signal<Record<string, any>>({});
+  private _expressionsAtom = Atom.make<Record<string, ParsedExpression>>({});
+  private _valuesByCellIdAtom = Atom.make<Record<string, any>>({});
+  private _valuesByNameAtom = Atom.make<Record<string, any>>({});
 
-  constructor(private readonly _notebook: Notebook.Notebook) {}
+  constructor(
+    private readonly _notebook: Notebook.Notebook,
+    private readonly _registry: Registry.Registry,
+  ) {}
 
   /**
-   * Parsed expressions by cell ID.
+   * Atom for parsed expressions by cell ID.
    */
-  get expressions(): Signal<Record<string, ParsedExpression>> {
-    return this._expressions;
+  get expressions(): Atom.Atom<Record<string, ParsedExpression>> {
+    return this._expressionsAtom;
   }
 
   /**
-   * Computed values by cell ID.
+   * Get current expressions by cell ID.
    */
-  get values(): Signal<Record<string, any>> {
-    return this._values;
+  getExpressions(): Record<string, ParsedExpression> {
+    return this._registry.get(this._expressionsAtom);
+  }
+
+  /**
+   * Atom for computed values by cell ID.
+   */
+  get values(): Atom.Atom<Record<string, any>> {
+    return this._valuesByCellIdAtom;
+  }
+
+  /**
+   * Get computed values by cell ID.
+   */
+  getValues(): Record<string, any> {
+    return this._registry.get(this._valuesByCellIdAtom);
+  }
+
+  /**
+   * Atom for computed values by name.
+   */
+  get valuesByName(): Atom.Atom<Record<string, any>> {
+    return this._valuesByNameAtom;
+  }
+
+  /**
+   * Get current values by name.
+   */
+  getValuesByName(): Record<string, any> {
+    return this._registry.get(this._valuesByNameAtom);
+  }
+
+  /**
+   * Get computed value by cell ID.
+   */
+  getValue(cellId: string): any {
+    return this._registry.get(this._valuesByCellIdAtom)[cellId];
   }
 
   /**
    * Compute values.
    */
-  evaluate() {
+  async evaluate() {
     // Parse expressions.
     const { expressions, dependencyGraph } = this.parse();
-    this._values.value = {};
+    this._registry.set(this._valuesByCellIdAtom, {});
+    this._registry.set(this._valuesByNameAtom, {});
 
     // Create a map of cell IDs to expressions for easy lookup.
     const cellExpressions = new Map<string, ParsedExpression>();
@@ -65,7 +106,7 @@ export class ComputeGraph {
         continue;
       }
 
-      const cellSource = this._notebook.cells.find((cell) => cell.id === cellId)?.script?.target?.content;
+      const cellSource = this._notebook.cells.find((cell) => cell.id === cellId)?.source?.target?.content;
       if (!cellSource) {
         log.error('no source for cell', { cellId });
         continue;
@@ -90,7 +131,7 @@ export class ComputeGraph {
               rhs = rhs.slice(0, -1).trim();
             }
 
-            const result = evalScript(rhs, valuesByName);
+            const result = await this.eval(rhs, valuesByName);
             valuesByName[expr.name] = result;
             if (typeof result !== 'function') {
               valuesByCellId[cellId] = result;
@@ -98,18 +139,24 @@ export class ComputeGraph {
           }
         } else {
           // For expressions without assignment, just evaluate.
-          const result = evalScript(cellSource, valuesByName);
+          const result = await this.eval(cellSource, valuesByName);
           valuesByCellId[cellId] = result;
         }
       } catch (error) {
+        // TODO(burdon): Set error state.
         log.error('error evaluating cell', { cellId, error });
       }
     }
 
-    this._values.value = valuesByCellId;
+    this._registry.set(this._valuesByCellIdAtom, valuesByCellId);
+    this._registry.set(this._valuesByNameAtom, valuesByName);
     return valuesByCellId;
   }
 
+  private async eval(source: string, values: Record<string, any>) {
+    return evalScript(source, values);
+  }
+
   /**
    * Parse expressions.
    */
@@ -117,7 +164,7 @@ export class ComputeGraph {
     const expressions = this._notebook.cells
       .filter((cell) => cell.type === 'script')
       .reduce<Record<string, ParsedExpression>>((acc, cell) => {
-        const text = cell.script?.target?.content.trim();
+        const text = cell.source?.target?.content.trim();
         if (text) {
           const parsed = this._parser.parseExpression(text);
           acc[cell.id] = parsed;
@@ -128,7 +175,7 @@ export class ComputeGraph {
 
     // Build dependency graph.
     const dependencyGraph = this.buildDependencyGraph(expressions);
-    this._expressions.value = expressions;
+    this._registry.set(this._expressionsAtom, expressions);
     return { expressions, dependencyGraph };
   }
 

package/src/notebook/eval.ts

@@ -7,7 +7,7 @@ import { trim } from '@dxos/util';
 /**
  * Evaluate the script (with dependencies as arguments).
  */
-export const evalScript = (code: string, deps: Record<string, any> = {}) => {
+export const evalScript = async (code: string, deps: Record<string, any> = {}) => {
   // Create a sandboxed environment that blocks access to window and document.
   const sandbox = {
     ...deps,

package/src/notebook/index.ts

@@ -2,4 +2,4 @@
 // Copyright 2025 DXOS.org
 //
 
-export * from './notebook';
+export * from './compute-graph';

package/src/notebook/vfs-parser.ts

@@ -42,6 +42,7 @@ export class VirtualTypeScriptParser {
   protected compilerOptions: ts.CompilerOptions = {
     target: ts.ScriptTarget.ES2020,
     module: ts.ModuleKind.ESNext,
+    moduleResolution: ts.ModuleResolutionKind.Bundler,
     strict: true,
     esModuleInterop: true,
     skipLibCheck: true,
@@ -91,7 +92,9 @@ export class VirtualTypeScriptParser {
     // Analyze each file.
     files.forEach((file) => {
       const sourceFile = env.getSourceFile(file.filename);
-      if (!sourceFile || !typeChecker) return;
+      if (!sourceFile || !typeChecker) {
+        return;
+      }
 
       const fileResults = this.analyzeSourceFile(sourceFile, typeChecker);
       results.push(...fileResults);
@@ -207,7 +210,9 @@ export class VirtualTypeScriptParser {
     signature: ts.Signature | undefined,
     typeChecker: ts.TypeChecker,
   ): Array<{ name: string; type: string }> {
-    if (!signature) return [];
+    if (!signature) {
+      return [];
+    }
 
     return signature.parameters.map((param) => ({
       name: param.getName(),
@@ -429,7 +434,9 @@ export class NotebookVirtualParser extends VirtualTypeScriptParser {
         const previousExports = new Set<string>();
         for (const [_prevCellId, prevAnalysis] of cellAnalysis) {
           prevAnalysis.exports.forEach((exp) => {
-            if (exp.name) previousExports.add(exp.name);
+            if (exp.name) {
+              previousExports.add(exp.name);
+            }
           });
         }
 

package/src/operations/access-token-created.ts

@@ -0,0 +1,37 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+import * as Predicate from 'effect/Predicate';
+
+import { LayoutOperation } from '@dxos/app-toolkit';
+import { Operation } from '@dxos/compute';
+import { IntegrationOperation } from '@dxos/plugin-integration';
+
+import { defaultScriptsForIntegration } from '#meta';
+
+import { DEPLOYMENT_DIALOG } from '../constants';
+import { templates } from '../templates';
+
+const handler: Operation.WithHandler<typeof IntegrationOperation.AccessTokenCreated> =
+  IntegrationOperation.AccessTokenCreated.pipe(
+    Operation.withHandler(
+      Effect.fnUntraced(function* ({ accessToken }) {
+        const scriptTemplates = (defaultScriptsForIntegration[accessToken.source] ?? [])
+          .map((id) => templates.find((t) => t.id === id))
+          .filter(Predicate.isNotNullable);
+
+        if (scriptTemplates.length > 0) {
+          yield* Operation.invoke(LayoutOperation.UpdateDialog, {
+            subject: DEPLOYMENT_DIALOG,
+            blockAlign: 'start',
+            state: true,
+            props: { accessToken, scriptTemplates },
+          });
+        }
+      }),
+    ),
+  );
+
+export default handler;

package/src/operations/create-script.ts

@@ -0,0 +1,46 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Octokit } from '@octokit/core';
+import * as Effect from 'effect/Effect';
+
+import { Script, Operation } from '@dxos/compute';
+
+import { templates } from '../templates';
+import { ScriptOperation } from '../types';
+
+const handler: Operation.WithHandler<typeof ScriptOperation.CreateScript> = ScriptOperation.CreateScript.pipe(
+  Operation.withHandler(
+    Effect.fnUntraced(function* ({ name, gistUrl, initialTemplateId }) {
+      let source = templates[0].source;
+      let scriptName = name;
+
+      const gistId = gistUrl?.split('/').at(-1);
+      if (gistId) {
+        const octokit = new Octokit();
+        const response = yield* Effect.promise(() =>
+          octokit.request('GET /gists/{gist_id}', {
+            gist_id: gistId,
+          }),
+        );
+        const gistContent = Object.values(response.data.files ?? {})[0]?.content;
+        if (gistContent) {
+          source = gistContent;
+        }
+      }
+
+      if (initialTemplateId) {
+        const template = templates.find((template) => template.id === initialTemplateId);
+        if (template) {
+          source = template.source;
+          scriptName = scriptName || template.name;
+        }
+      }
+
+      return { object: Script.make({ name: scriptName, source }) };
+    }),
+  ),
+);
+
+export default handler;

package/src/operations/index.ts

@@ -0,0 +1,10 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { OperationHandlerSet } from '@dxos/compute';
+
+export const ScriptOperationHandlerSet = OperationHandlerSet.lazy(
+  () => import('./access-token-created'),
+  () => import('./create-script'),
+);

package/src/plugin.ts

@@ -0,0 +1,11 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Plugin } from '@dxos/app-framework';
+
+import { meta } from './meta';
+
+export const ScriptPlugin = Plugin.lazy(meta, () => import('#plugin'));
+
+export { ScriptOperationHandlerSet } from './operations';