@dxos/plugin-script 0.8.4-main.bc674ce → 0.8.4-main.bcb3aa67d6

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.change(sourceTarget, (obj) => {
+        obj.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.change(sourceTarget, (obj) => {
+        obj.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.change(sourceTarget, (obj) => {
+        obj.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/operations/access-token-created.ts

@@ -0,0 +1,36 @@
+//
+// 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/operation';
+import { TokenManagerOperation } from '@dxos/plugin-token-manager/operations';
+
+import { DEPLOYMENT_DIALOG } from '../constants';
+import { defaultScriptsForIntegration } from '#meta';
+import { templates } from '../templates';
+
+const handler: Operation.WithHandler<typeof TokenManagerOperation.AccessTokenCreated> =
+  TokenManagerOperation.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,47 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Octokit } from '@octokit/core';
+import * as Effect from 'effect/Effect';
+
+import { Script } from '@dxos/functions';
+import { Operation } from '@dxos/operation';
+
+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 { Database } from '@dxos/echo';
+import { Script } from '@dxos/functions';
+import { Operation } from '@dxos/operation';
+
+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/operation';
+
+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/operation';
 
-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 { Database, Obj, Ref } from '@dxos/echo';
+import { Operation } from '@dxos/operation';
 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.change(loadedGame, (obj) => {
+        obj.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() };
-  }),
-});
+    }),
+  ),
+);