@dxos/plugin-script 0.8.4-main.66e292d → 0.8.4-main.69d29f4

package/src/hooks/deploy.ts

@@ -11,7 +11,7 @@ import { type Client, useClient } from '@dxos/react-client';
 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 { errorMessageColors } from '@dxos/ui-theme';
 
 import { meta } from '../meta';
 import { deployScript, getFunctionUrl, isScriptDeployed } from '../util';
@@ -25,8 +25,10 @@ export type DeployState = {
   error: string;
 };
 
+import { type ScriptToolbarStateStore } from './useToolbarState';
+
 export type CreateDeployOptions = {
-  state: Partial<DeployState>;
+  state: ScriptToolbarStateStore;
   script: Script.Script;
   fn: Function.Function;
   space?: Space;
@@ -36,12 +38,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 && errorMessageColors,
   });
 
   const deployAction = createMenuAction<DeployActionProperties>(
@@ -51,39 +55,39 @@ 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,
     },
   );
 
@@ -97,29 +101,32 @@ export const createDeploy = ({ state, script, space, fn, client, existingFunctio
   };
 };
 
-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 [fn] = useQuery(space?.db, Query.type(Function.Function, { 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!, (s) => {
+          s.content = formatted;
+        });
       } catch (err: any) {
         // TODO(wittjosiah): Show error in UI.
         log.catch(err);

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, (s) => {
+          s.name = template.name;
+          const meta = Obj.getMeta(s);
+          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, (s) => {
+            s.content = template.source;
+          });
         }
       },
       {

package/src/hooks/useCompiler.ts

@@ -0,0 +1,24 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { useCapabilities, usePluginManager } from '@dxos/app-framework/react';
+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;
+};

package/src/hooks/useCreateAndDeployScriptTemplates.ts

@@ -2,20 +2,18 @@
 // Copyright 2025 DXOS.org
 //
 
-import * as Function from 'effect/Function';
 import { useCallback, useState } from 'react';
 
-import { chain, createIntent } from '@dxos/app-framework';
-import { useIntentDispatcher } from '@dxos/app-framework/react';
+import { useOperationInvoker } from '@dxos/app-framework/react';
 import { Obj } 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 } from '@dxos/react-client';
 import { type Space } from '@dxos/react-client/echo';
 
 import { type Template } from '../templates';
-import { ScriptAction } from '../types';
+import { ScriptOperation } from '../types';
 import { deployScript } from '../util';
 
 type DeploymentStatus = 'idle' | 'pending' | 'success' | 'error';
@@ -28,7 +26,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);
@@ -40,24 +38,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(Script.Script, 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,39 @@
 // Copyright 2025 DXOS.org
 //
 
-import { useMemo } from 'react';
-
-import { live } from '@dxos/live-object';
+import { Atom, RegistryContext, useAtomValue } from '@effect-atom/atom-react';
+import { useContext, useMemo } from 'react';
 
 import { type DeployState } from './deploy';
 
 export type ScriptToolbarState = Partial<DeployState>;
 
+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;
+};
+
 // TODO(burdon): Replace with context provider?
-export const useToolbarState = (initialState: ScriptToolbarState = {}) => {
-  return useMemo(() => live<ScriptToolbarState>(initialState), []);
+export const useToolbarState = (initialState: ScriptToolbarState = {}): ScriptToolbarStateStore => {
+  const registry = useContext(RegistryContext);
+  const atom = useMemo(() => Atom.make<ScriptToolbarState>(initialState), []);
+  const value = useAtomValue(atom);
+
+  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, value],
+  );
 };

package/src/index.ts

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

package/src/meta.ts

@@ -2,10 +2,10 @@
 // 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 = {
+export const meta: Plugin.Meta = {
   id: 'dxos.org/plugin/script',
   name: 'Scripts',
   description: trim`

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

@@ -2,16 +2,20 @@
 // 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);
+    const graph = new ComputeGraph(notebook, registry);
     const result = graph.parse();
 
     const getId = (i: number) => notebook.cells[i].id;
@@ -34,13 +38,17 @@ describe('notebook', () => {
   });
 
   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.
-    if (notebook.cells[2].source?.target) {
-      notebook.cells[2].source.target.content = 'b = typeof window';
+    const sourceTarget = notebook.cells[2].source?.target;
+    if (sourceTarget) {
+      Obj.change(sourceTarget, (t) => {
+        t.content = 'b = typeof window';
+      });
     }
 
-    const graph = new ComputeGraph(notebook);
+    const graph = new ComputeGraph(notebook, registry);
     graph.parse();
     const values = await graph.evaluate();
 
@@ -48,8 +56,10 @@ describe('notebook', () => {
     expect(values[notebook.cells[2].id]).toBe('undefined');
 
     // Test document access.
-    if (notebook.cells[2].source?.target) {
-      notebook.cells[2].source.target.content = 'b = typeof document';
+    if (sourceTarget) {
+      Obj.change(sourceTarget, (t) => {
+        t.content = 'b = typeof document';
+      });
     }
     graph.parse();
     const values2 = await graph.evaluate();
@@ -58,8 +68,10 @@ describe('notebook', () => {
     expect(values2[notebook.cells[2].id]).toBe('undefined');
 
     // Test that safe globals still work.
-    if (notebook.cells[2].source?.target) {
-      notebook.cells[2].source.target.content = 'b = Math.max(100, 200)';
+    if (sourceTarget) {
+      Obj.change(sourceTarget, (t) => {
+        t.content = 'b = Math.max(100, 200)';
+      });
     }
     graph.parse();
     const values3 = await graph.evaluate();

package/src/notebook/compute-graph.ts

@@ -2,7 +2,7 @@
 // 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';
 
@@ -18,38 +18,62 @@ import { type ParsedExpression, VirtualTypeScriptParser } from './vfs-parser';
 export class ComputeGraph {
   private readonly _parser = new VirtualTypeScriptParser();
 
-  private _expressions = signal<Record<string, ParsedExpression>>({});
-  private _valuesByCellId = signal<Record<string, any>>({});
-  private _valuesByName = 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._valuesByCellId;
+  getExpressions(): Record<string, ParsedExpression> {
+    return this._registry.get(this._expressionsAtom);
   }
 
   /**
-   * Computed values by name.
+   * Atom for computed values by cell ID.
    */
-  get valuesByName(): Signal<Record<string, any>> {
-    return this._valuesByName;
+  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) {
-    return this._valuesByCellId.value[cellId];
+  getValue(cellId: string): any {
+    return this._registry.get(this._valuesByCellIdAtom)[cellId];
   }
 
   /**
@@ -58,8 +82,8 @@ export class ComputeGraph {
   async evaluate() {
     // Parse expressions.
     const { expressions, dependencyGraph } = this.parse();
-    this._valuesByCellId.value = {};
-    this._valuesByName.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>();
@@ -124,8 +148,8 @@ export class ComputeGraph {
       }
     }
 
-    this._valuesByCellId.value = valuesByCellId;
-    this._valuesByName.value = valuesByName;
+    this._registry.set(this._valuesByCellIdAtom, valuesByCellId);
+    this._registry.set(this._valuesByNameAtom, valuesByName);
     return valuesByCellId;
   }
 
@@ -151,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/templates/anthropic.ts

@@ -0,0 +1,42 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as LanguageModel from '@effect/ai/LanguageModel';
+import * as Chunk from 'effect/Chunk';
+import * as Effect from 'effect/Effect';
+import * as Schema from 'effect/Schema';
+import * as Stream from 'effect/Stream';
+
+import { AiService } from '@dxos/ai';
+import { defineFunction } from '@dxos/functions';
+
+export default defineFunction({
+  key: 'dxos.org/script/anthropic',
+  name: 'Anthropic Chat',
+  description: 'Chat with Anthropic',
+  inputSchema: Schema.Struct({
+    message: Schema.String,
+  }),
+  services: [AiService.AiService],
+  handler: ({ data }) => {
+    return Effect.gen(function* () {
+      const model = (yield* AiService.AiService).model('@anthropic/claude-sonnet-4-5');
+      //
+      // Basic example.
+      //
+      const { text } = yield* LanguageModel.generateText({ prompt: data.message }).pipe(Effect.provide(model));
+
+      //
+      // Streaming example.
+      //
+      const parts = yield* LanguageModel.streamText({
+        prompt: 'Count from 1 to 5, one number per line.',
+      }).pipe(Stream.runCollect, Effect.map(Chunk.toArray), Effect.provide(model));
+      const textDeltas = parts.filter((p) => p.type === 'text-delta');
+      const fullText = textDeltas.map((p) => (p as { delta: string }).delta).join('');
+
+      return { response: text, streamText: fullText };
+    });
+  },
+});

package/src/templates/chess-bot.ts

@@ -0,0 +1,58 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Chess as ChessJS } from 'chess.js';
+import * as Effect from 'effect/Effect';
+import * as Schema from 'effect/Schema';
+
+import { Database, Obj, Type } from '@dxos/echo';
+import { defineFunction } from '@dxos/functions';
+import { Chess } from '@dxos/plugin-chess/types';
+
+export default defineFunction({
+  key: 'dxos.org/script/chess-bot',
+  name: 'Chess Bot',
+  description: 'Plays a random move in a chess game.',
+
+  inputSchema: Schema.Struct({
+    game: Type.Ref(Chess.Game).annotations({
+      description: 'The chess game to comment on.',
+    }),
+    player: Schema.optional(Schema.Literal('white', 'black')).annotations({
+      description: 'The player to play the game as.',
+    }),
+  }),
+
+  outputSchema: Schema.Struct({
+    state: Schema.String.annotations({
+      description: 'The state of the game as an ASCII art board.',
+    }),
+  }),
+
+  types: [Chess.Game],
+  services: [Database.Service],
+
+  handler: Effect.fnUntraced(function* ({ data: { game, player = 'black' } }) {
+    const loadedGame = yield* Database.Service.load(game);
+    const chess = new ChessJS();
+    chess.loadPgn(loadedGame.pgn ?? '');
+    if (chess.turn() !== (player === 'white' ? 'w' : 'b')) {
+      return { state: chess.ascii() };
+    }
+
+    const moves = chess.moves({ verbose: true });
+    const move = moves[Math.floor(Math.random() * moves.length)];
+    if (!move) {
+      return { state: chess.ascii() };
+    }
+
+    chess.move(move.san);
+    const newPgn = chess.pgn();
+    Obj.change(loadedGame, (g) => {
+      g.pgn = newPgn;
+    });
+    yield* Database.Service.flush();
+    return { state: chess.ascii() };
+  }),
+});