@dxos/plugin-script 0.8.4-main.9735255 → 0.8.4-main.abd8ff62ef

package/src/hooks/format.ts

@@ -6,12 +6,12 @@ import { format } from 'prettier';
 import prettierPluginEstree from 'prettier/plugins/estree';
 import prettierPluginTypescript from 'prettier/plugins/typescript';
 
+import { type Script } from '@dxos/compute';
 import { Obj } from '@dxos/echo';
-import { type Script } from '@dxos/functions';
 import { log } from '@dxos/log';
 import { createMenuAction } from '@dxos/react-ui-menu';
 
-import { meta } from '../meta';
+import { meta } from '#meta';
 
 export type FormatActionProperties = { type: 'format' };
 
@@ -30,8 +30,8 @@ export const createFormat = (script: Script.Script) => {
           semi: true,
           singleQuote: true,
         });
-        Obj.change(script.source.target!, (s) => {
-          s.content = formatted;
+        Obj.update(script.source.target!, (obj) => {
+          obj.content = formatted;
         });
       } catch (err: any) {
         // TODO(wittjosiah): Show error in UI.
@@ -39,7 +39,7 @@ export const createFormat = (script: Script.Script) => {
       }
     },
     {
-      label: ['format label', { ns: meta.id }],
+      label: ['format.label', { ns: meta.id }],
       icon: 'ph--magic-wand--regular',
     },
   );
@@ -50,6 +50,7 @@ export const createFormat = (script: Script.Script) => {
       {
         source: 'root',
         target: 'format',
+        relation: 'child',
       },
     ],
   };

package/src/hooks/template.ts

@@ -2,8 +2,9 @@
 // Copyright 2025 DXOS.org
 //
 
+import { Script } from '@dxos/compute';
 import { Obj } from '@dxos/echo';
-import { FUNCTIONS_PRESET_META_KEY, type Script } from '@dxos/functions';
+import { FUNCTIONS_PRESET_META_KEY } from '@dxos/functions';
 import { createMenuAction } from '@dxos/react-ui-menu';
 
 import { templates } from '../templates';
@@ -15,9 +16,9 @@ const createTemplateSelectActions = (script: Script.Script) => {
     return createMenuAction<TemplateActionProperties>(
       `template--${template.id}`,
       () => {
-        Obj.change(script, (s) => {
-          s.name = template.name;
-          const meta = Obj.getMeta(s);
+        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);
@@ -27,8 +28,8 @@ const createTemplateSelectActions = (script: Script.Script) => {
           }
         });
         if (script.source?.target) {
-          Obj.change(script.source.target, (s) => {
-            s.content = template.source;
+          Obj.update(script.source.target, (obj) => {
+            obj.content = template.source;
           });
         }
       },
@@ -46,8 +47,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

@@ -2,13 +2,14 @@
 // Copyright 2025 DXOS.org
 //
 
-import { useCapabilities, usePluginManager } from '@dxos/app-framework/react';
+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';
-import { ScriptEvents } from '../types';
-import { ScriptCapabilities } from '../types';
 
 /**
  * Asynchronously sets up the compiler and returns it.

package/src/hooks/useCreateAndDeployScriptTemplates.ts

@@ -4,16 +4,17 @@
 
 import { useCallback, useState } from 'react';
 
-import { useOperationInvoker } from '@dxos/app-framework/react';
+import { useOperationInvoker } from '@dxos/app-framework/ui';
+import { Script } from '@dxos/compute';
 import { Obj } from '@dxos/echo';
-import { Script } from '@dxos/functions';
 import { invariant } from '@dxos/invariant';
-import { SpaceOperation } from '@dxos/plugin-space/types';
+import { SpaceOperation } from '@dxos/plugin-space/operations';
 import { useClient } from '@dxos/react-client';
 import { type Space } from '@dxos/react-client/echo';
 
+import { ScriptOperation } from '#operations';
+
 import { type Template } from '../templates';
-import { ScriptOperation } from '../types';
 import { deployScript } from '../util';
 
 type DeploymentStatus = 'idle' | 'pending' | 'success' | 'error';

package/src/hooks/useToolbarState.ts

@@ -2,8 +2,11 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Atom, RegistryContext, useAtomValue } from '@effect-atom/atom-react';
-import { useContext, useMemo } from 'react';
+import { Atom } from '@effect-atom/atom-react';
+import { useMemo } from 'react';
+
+import { Capabilities } from '@dxos/app-framework';
+import { useCapability } from '@dxos/app-framework/ui';
 
 import { type DeployState } from './deploy';
 
@@ -16,11 +19,9 @@ export type ScriptToolbarStateStore = {
   set: <K extends keyof ScriptToolbarState>(key: K, value: ScriptToolbarState[K]) => void;
 };
 
-// TODO(burdon): Replace with context provider?
 export const useToolbarState = (initialState: ScriptToolbarState = {}): ScriptToolbarStateStore => {
-  const registry = useContext(RegistryContext);
+  const registry = useCapability(Capabilities.AtomRegistry);
   const atom = useMemo(() => Atom.make<ScriptToolbarState>(initialState), []);
-  const value = useAtomValue(atom);
 
   return useMemo(
     () => ({
@@ -35,6 +36,6 @@ export const useToolbarState = (initialState: ScriptToolbarState = {}): ScriptTo
         registry.set(atom, { ...registry.get(atom), [key]: v });
       },
     }),
-    [atom, registry, value],
+    [atom, registry],
   );
 };

package/src/index.ts

@@ -2,9 +2,12 @@
 // Copyright 2023 DXOS.org
 //
 
+import { Plugin } from '@dxos/app-framework';
+
+import { meta } from './meta';
+
+export const ScriptPlugin = Plugin.lazy(meta, () => import('#plugin'));
+
 export { ScriptCapabilities, ScriptEvents } from './types';
-export * from './components';
 export * from './meta';
 export * from './util';
-
-export * from './ScriptPlugin';

package/src/meta.ts

@@ -6,7 +6,7 @@ import { type Plugin } from '@dxos/app-framework';
 import { trim } from '@dxos/util';
 
 export const meta: Plugin.Meta = {
-  id: 'dxos.org/plugin/script',
+  id: 'org.dxos.plugin.script',
   name: 'Scripts',
   description: trim`
     Write and deploy custom JavaScript functions that extend your workspace capabilities.
@@ -22,5 +22,5 @@ export const meta: Plugin.Meta = {
 // 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

@@ -7,7 +7,7 @@ import { describe, expect, test } from 'vitest';
 
 import { Obj } from '@dxos/echo';
 
-import { createNotebook } from '../testing';
+import { createNotebook } from '#testing';
 
 import { ComputeGraph } from './compute-graph';
 
@@ -43,8 +43,8 @@ describe('notebook', () => {
     // Replace one of the cells with code that tries to access window/document.
     const sourceTarget = notebook.cells[2].source?.target;
     if (sourceTarget) {
-      Obj.change(sourceTarget, (t) => {
-        t.content = 'b = typeof window';
+      Obj.update(sourceTarget, (sourceTarget) => {
+        sourceTarget.content = 'b = typeof window';
       });
     }
 
@@ -57,8 +57,8 @@ describe('notebook', () => {
 
     // Test document access.
     if (sourceTarget) {
-      Obj.change(sourceTarget, (t) => {
-        t.content = 'b = typeof document';
+      Obj.update(sourceTarget, (sourceTarget) => {
+        sourceTarget.content = 'b = typeof document';
       });
     }
     graph.parse();
@@ -69,8 +69,8 @@ describe('notebook', () => {
 
     // Test that safe globals still work.
     if (sourceTarget) {
-      Obj.change(sourceTarget, (t) => {
-        t.content = 'b = Math.max(100, 200)';
+      Obj.update(sourceTarget, (sourceTarget) => {
+        sourceTarget.content = 'b = Math.max(100, 200)';
       });
     }
     graph.parse();

package/src/notebook/compute-graph.ts

@@ -6,7 +6,7 @@ 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';

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/operations';
+
+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 { CreateScript } from './definitions';
+
+const handler: Operation.WithHandler<typeof CreateScript> = 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/definitions.ts

@@ -0,0 +1,40 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Schema from 'effect/Schema';
+
+import { Script, Operation } from '@dxos/compute';
+import { Database } from '@dxos/echo';
+
+import { meta } from '#meta';
+
+import { templates } from '../templates';
+
+const SCRIPT_OPERATION = `${meta.id}.operation`;
+
+export const ScriptProps = Schema.Struct({
+  name: Schema.optional(Schema.String),
+  gistUrl: Schema.optional(Schema.String.annotations({ title: 'Import from Gist (url)' })),
+  initialTemplateId: Schema.Literal(...templates.map(({ id }) => id)).pipe(
+    Schema.annotations({ title: 'Template' }),
+    Schema.optional,
+  ),
+});
+
+export const NotebookProps = Schema.Struct({
+  name: Schema.optional(Schema.String),
+});
+
+export const CreateScript = Operation.make({
+  meta: { key: `${SCRIPT_OPERATION}.create-script`, name: 'Create Script' },
+  input: Schema.extend(
+    ScriptProps,
+    Schema.Struct({
+      db: Database.Database,
+    }),
+  ),
+  output: Schema.Struct({
+    object: Script.Script,
+  }),
+});

package/src/operations/index.ts

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

package/src/templates/anthropic.ts

@@ -9,23 +9,30 @@ import * as Schema from 'effect/Schema';
 import * as Stream from 'effect/Stream';
 
 import { AiService } from '@dxos/ai';
-import { defineFunction } from '@dxos/functions';
+import { Operation } from '@dxos/compute';
 
-export default defineFunction({
-  key: 'dxos.org/script/anthropic',
-  name: 'Anthropic Chat',
-  description: 'Chat with Anthropic',
-  inputSchema: Schema.Struct({
+const Anthropic = Operation.make({
+  meta: {
+    key: 'org.dxos.script.anthropic',
+    name: 'Anthropic Chat',
+    description: 'Chat with Anthropic',
+  },
+  input: Schema.Struct({
     message: Schema.String,
   }),
+  output: Schema.Any,
   services: [AiService.AiService],
-  handler: ({ data }) => {
-    return Effect.gen(function* () {
+});
+
+export default Anthropic.pipe(
+  Operation.withHandler(
+    Effect.fn(function* ({ message }) {
       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));
+      const { text } = yield* LanguageModel.generateText({ prompt: message }).pipe(Effect.provide(model));
 
       //
       // Streaming example.
@@ -37,6 +44,6 @@ export default defineFunction({
       const fullText = textDeltas.map((p) => (p as { delta: string }).delta).join('');
 
       return { response: text, streamText: fullText };
-    });
-  },
-});
+    }),
+  ),
+);

package/src/templates/chat.ts

@@ -76,7 +76,7 @@ export default async ({ data: { bodyText }, context: { space, ai } }: any) => {
 
 const getContext = async ({ space }: any) => {
   let context = '';
-  const { objects: docs } = await space.crud.query({ __typename: 'dxos.org/type/Document' }).run();
+  const { objects: docs } = await space.crud.query({ __typename: 'org.dxos.type.document' }).run();
   for (const doc of docs) {
     const { content } = await space.crud.query({ id: doc.content }).first();
     context += content + '\n\n';

package/src/templates/chess-bot.ts

@@ -6,53 +6,56 @@ 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 { Operation } from '@dxos/compute';
+import { Database, Obj, Ref } from '@dxos/echo';
 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({
+const ChessBot = Operation.make({
+  meta: {
+    key: 'org.dxos.script.chess-bot',
+    name: 'Chess Bot',
+    description: 'Plays a random move in a chess game.',
+  },
+  input: Schema.Struct({
+    game: Ref.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({
+  output: 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) {
+export default ChessBot.pipe(
+  Operation.withHandler(
+    Effect.fnUntraced(function* ({ game, player = 'black' }) {
+      const loadedGame = yield* Database.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.update(loadedGame, (loadedGame) => {
+        loadedGame.pgn = newPgn;
+      });
+      yield* Database.flush();
       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() };
-  }),
-});
+    }),
+  ),
+);