@dxos/plugin-script 0.8.4-main.c85a9c8dae → 0.8.4-main.dfabb4ec29

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';
+
+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';

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,58 @@ import { Chess as ChessJS } from 'chess.js';
 import * as Effect from 'effect/Effect';
 import * as Schema from 'effect/Schema';
 
-import { Database, Obj, Ref } 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: Ref.Ref(Chess.Game).annotations({
+import { Operation } from '@dxos/compute';
+import { Database, Obj } from '@dxos/echo';
+import { Chess } from '@dxos/plugin-chess';
+import { GameRef, Game, loadGame } from '@dxos/plugin-game';
+
+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: GameRef(Chess.State).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],
+  types: [Game, Chess.State],
   services: [Database.Service],
+});
 
-  handler: Effect.fnUntraced(function* ({ data: { 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) {
+export default ChessBot.pipe(
+  Operation.withHandler(
+    Effect.fnUntraced(function* ({ game, player = 'black' }) {
+      const { variant } = yield* loadGame(game, Chess.State);
+      const chess = new ChessJS();
+      chess.loadPgn(variant.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(variant, (variant) => {
+        const mutable = variant as Obj.Mutable<typeof variant>;
+        mutable.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.flush();
-    return { state: chess.ascii() };
-  }),
-});
+    }),
+  ),
+);