@dxos/plugin-script 0.8.4-main.3c1ae3b → 0.8.4-main.3fbcb4aa9b

package/src/blueprints/functions/update.ts

@@ -0,0 +1,68 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { next as A, type Doc } from '@automerge/automerge';
+import * as Effect from 'effect/Effect';
+
+import { type Script, Operation } from '@dxos/compute';
+import { Database, Obj } from '@dxos/echo';
+import { DocAccessor, createDocAccessor } from '@dxos/echo-db';
+
+import { Update } from './definitions';
+
+export default Update.pipe(
+  Operation.withHandler(
+    Effect.fn(function* ({ function: fn, name, description, edits }) {
+      const loaded = yield* Database.load(fn);
+      if (!loaded.source) {
+        return yield* Effect.fail(new Error('Function has no source script.'));
+      }
+      const script = (yield* Database.load(loaded.source)) as Script.Script;
+
+      if (name !== undefined || description !== undefined) {
+        Obj.update(script, (script) => {
+          if (name !== undefined) {
+            script.name = name;
+          }
+          if (description !== undefined) {
+            script.description = description;
+          }
+        });
+      }
+
+      if (edits && edits.length > 0) {
+        const text = yield* Database.load(script.source);
+        const accessor = createDocAccessor(text, ['content']);
+
+        for (const edit of edits) {
+          accessor.handle.change((doc: Doc<typeof text>) => {
+            const source = DocAccessor.getValue<string>(accessor);
+            if (edit.replaceAll) {
+              let idx = source.indexOf(edit.oldString);
+              while (idx !== -1) {
+                A.splice(doc, accessor.path as A.Prop[], idx, edit.oldString.length, edit.newString);
+                const updated = DocAccessor.getValue<string>(accessor);
+                idx = updated.indexOf(edit.oldString, idx + edit.newString.length);
+              }
+            } else {
+              const idx = source.indexOf(edit.oldString);
+              if (idx === -1) {
+                throw new Error(`Edit not found: ${JSON.stringify(edit.oldString)}`);
+              }
+              A.splice(doc, accessor.path as A.Prop[], idx, edit.oldString.length, edit.newString);
+            }
+          });
+        }
+
+        Obj.update(script, (script) => {
+          script.changed = true;
+        });
+      }
+
+      return {
+        function: Obj.getDXN(loaded).toString(),
+      };
+    }),
+  ),
+);

package/src/blueprints/index.ts

@@ -0,0 +1,5 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+export { default as ScriptBlueprint } from './script-blueprint';

package/src/blueprints/script-blueprint.ts

@@ -0,0 +1,55 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Blueprint, Template } from '@dxos/compute';
+import { trim } from '@dxos/util';
+
+import {
+  Create,
+  Read,
+  Update,
+  Delete,
+  Deploy,
+  Invoke,
+  InspectInvocations,
+  QueryDeployedFunctions,
+  InstallFunction,
+} from './functions';
+
+const BLUEPRINT_KEY = 'org.dxos.blueprint.script';
+
+const make = () =>
+  Blueprint.make({
+    key: BLUEPRINT_KEY,
+    name: 'Script',
+    agentCanEnable: true,
+    tools: Blueprint.toolDefinitions({
+      operations: [
+        Create,
+        Read,
+        Update,
+        Delete,
+        Deploy,
+        Invoke,
+        InspectInvocations,
+        QueryDeployedFunctions,
+        InstallFunction,
+      ],
+    }),
+    instructions: Template.make({
+      source: trim`
+        You can create, read, update, and delete scripts which contain TypeScript code.
+        You can deploy scripts to the Edge runtime and invoke deployed scripts.
+        You can inspect the invocation history of a deployed script.
+        You can query all functions deployed to the EDGE runtime and install them into the current space.
+      `,
+    }),
+  });
+
+const blueprint: Blueprint.Definition = {
+  key: BLUEPRINT_KEY,
+  make,
+};
+
+export default blueprint;

package/src/capabilities/app-graph-builder.ts

@@ -2,64 +2,46 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Atom } from '@effect-atom/atom-react';
-import * as Function from 'effect/Function';
-import * as Option from 'effect/Option';
+import * as Effect from 'effect/Effect';
 
-import { Capabilities, type PluginContext, contributes } from '@dxos/app-framework';
-import { Obj } from '@dxos/echo';
-import { Script } from '@dxos/functions';
-import { ATTENDABLE_PATH_SEPARATOR, PLANK_COMPANION_TYPE } from '@dxos/plugin-deck/types';
-import { createExtension } from '@dxos/plugin-graph';
+import { Capability } from '@dxos/app-framework';
+import { AppCapabilities, AppNode } from '@dxos/app-toolkit';
+import { Script } from '@dxos/compute';
+import { GraphBuilder } from '@dxos/plugin-graph';
 
-import { meta } from '../meta';
+import { meta } from '#meta';
 
-export default (context: PluginContext) =>
-  contributes(Capabilities.AppGraphBuilder, [
-    createExtension({
-      id: `${meta.id}/execute`,
-      connector: (node) =>
-        Atom.make((get) =>
-          Function.pipe(
-            get(node),
-            Option.flatMap((node) => (Obj.instanceOf(Script.Script, node.data) ? Option.some(node) : Option.none())),
-            Option.map((node) => [
-              {
-                id: [node.id, 'execute'].join(ATTENDABLE_PATH_SEPARATOR),
-                type: PLANK_COMPANION_TYPE,
-                data: 'execute',
-                properties: {
-                  label: ['script test label', { ns: meta.id }],
-                  icon: 'ph--terminal--regular',
-                  disposition: 'hidden',
-                },
-              },
-            ]),
-            Option.getOrElse(() => []),
-          ),
-        ),
-    }),
-    createExtension({
-      id: `${meta.id}/logs`,
-      connector: (node) =>
-        Atom.make((get) =>
-          Function.pipe(
-            get(node),
-            Option.flatMap((node) => (Obj.instanceOf(Script.Script, node.data) ? Option.some(node) : Option.none())),
-            Option.map((node) => [
-              {
-                id: [node.id, 'logs'].join(ATTENDABLE_PATH_SEPARATOR),
-                type: PLANK_COMPANION_TYPE,
-                data: 'logs',
-                properties: {
-                  label: ['script logs label', { ns: meta.id }],
-                  icon: 'ph--clock-countdown--regular',
-                  disposition: 'hidden',
-                },
-              },
-            ]),
-            Option.getOrElse(() => []),
-          ),
-        ),
-    }),
-  ]);
+export default Capability.makeModule(
+  Effect.fnUntraced(function* () {
+    const extensions = yield* Effect.all([
+      GraphBuilder.createTypeExtension({
+        id: 'execute',
+        type: Script.Script,
+        connector: () =>
+          Effect.succeed([
+            AppNode.makeCompanion({
+              id: 'execute',
+              label: ['script-test.label', { ns: meta.id }],
+              icon: 'ph--terminal--regular',
+              data: 'execute',
+            }),
+          ]),
+      }),
+      GraphBuilder.createTypeExtension({
+        id: 'logs',
+        type: Script.Script,
+        connector: () =>
+          Effect.succeed([
+            AppNode.makeCompanion({
+              id: 'logs',
+              label: ['script-logs.label', { ns: meta.id }],
+              icon: 'ph--clock-countdown--regular',
+              data: 'logs',
+            }),
+          ]),
+      }),
+    ]);
+
+    return Capability.contributes(AppCapabilities.AppGraphBuilder, extensions);
+  }),
+);

package/src/capabilities/artifact-definition.ts

@@ -5,19 +5,19 @@
 // ISSUE(burdon): defineArtifact
 // @ts-nocheck
 
+import * as Effect from 'effect/Effect';
 import * as Schema from 'effect/Schema';
 
 import { ToolResult, createTool } from '@dxos/ai';
-import { Capabilities, type PromiseIntentDispatcher, contributes, createIntent } from '@dxos/app-framework';
+import { Capabilities, Capability, type PromiseIntentDispatcher, createIntent } from '@dxos/app-framework';
 import { ArtifactId, createArtifactElement } from '@dxos/assistant';
-import { defineArtifact } from '@dxos/blueprints';
+import { defineArtifact, ScriptType } from '@dxos/compute';
 import { Filter, Obj, Ref } from '@dxos/echo';
-import { ScriptType } from '@dxos/functions';
 import { invariant } from '@dxos/invariant';
-import { SpaceAction } from '@dxos/plugin-space/types';
+import { SpaceAction } from '@dxos/plugin-space';
 import { type Space } from '@dxos/react-client/echo';
 
-import { meta } from '../meta';
+import { meta } from '#meta';
 
 // TODO(burdon): Factor out.
 declare global {
@@ -27,14 +27,15 @@ declare global {
   }
 }
 
-export default () => {
-  const definition = defineArtifact({
-    id: `artifact:${meta.id}`,
-    name: meta.name,
-    // TODO(dmaretskyi): Since writing scripts requires a lot of domain knowledge,
-    //  we should offload the work of synthesizing the code to a separate model.
-    //  The main reasoning model will give it a concrete task and the script model will synthesize the code, knowing all the docs.
-    instructions: `
+export default Capability.makeModule(() =>
+  Effect.sync(() => {
+    const definition = defineArtifact({
+      id: `artifact:${meta.id}`,
+      name: meta.name,
+      // TODO(dmaretskyi): Since writing scripts requires a lot of domain knowledge,
+      //  we should offload the work of synthesizing the code to a separate model.
+      //  The main reasoning model will give it a concrete task and the script model will synthesize the code, knowing all the docs.
+      instructions: `
       If the user explicitly requests you to write a script, you can create one.
       If the user requests you to change one of the existing script, you can update it.
       You must not create a script unless the user explicitly requests it.
@@ -104,7 +105,7 @@ export default () => {
       <handler_function>
         Async function that takes the argument in the form of:
 
-        type HandlerFunctionParam = {
+        type HandlerFunctionProp = {
           event: {
             data: T // The input schema
           },
@@ -143,82 +144,83 @@ export default () => {
         });
       </example>
   `,
-    schema: ScriptType,
-    tools: [
-      createTool(meta.id, {
-        name: 'create',
-        description: 'Create a new script. Returns the artifact definition for the script',
-        caption: 'Creating script...',
-        schema: Schema.Struct({
-          name: Schema.String.annotations({ description: 'The name of the script' }),
-          code: Schema.String.annotations({
-            description: 'The full code of the script in JavaScript or TypeScript. Must be valid executable code.',
+      schema: ScriptType,
+      tools: [
+        createTool(meta.id, {
+          name: 'create',
+          description: 'Create a new script. Returns the artifact definition for the script',
+          caption: 'Creating script...',
+          schema: Schema.Struct({
+            name: Schema.String.annotations({ description: 'The name of the script' }),
+            code: Schema.String.annotations({
+              description: 'The full code of the script in JavaScript or TypeScript. Must be valid executable code.',
+            }),
           }),
+          execute: async ({ name, code }, { extensions }) => {
+            invariant(extensions?.space, 'No space');
+            invariant(extensions?.dispatch, 'No intent dispatcher');
+            const script = Obj.make(ScriptType, { name, source: Ref.make(Text.make({ content: code })) });
+            extensions.space.db.add(script);
+            await extensions.space.db.flush();
+
+            const intent = createIntent(SpaceAction.AddObject, { target: extensions.space, object: script });
+            const { data, error } = await extensions.dispatch(intent);
+            if (!data || error) {
+              return ToolResult.Error(error?.message ?? 'Failed to create chess game');
+            }
+
+            return ToolResult.Success(createArtifactElement(script.id));
+          },
         }),
-        execute: async ({ name, code }, { extensions }) => {
-          invariant(extensions?.space, 'No space');
-          invariant(extensions?.dispatch, 'No intent dispatcher');
-          const script = Obj.make(ScriptType, { name, source: Ref.make(Text.make(code)) });
-          extensions.space.db.add(script);
-          await extensions.space.db.flush();
-
-          const intent = createIntent(SpaceAction.AddObject, { target: extensions.space, object: script });
-          const { data, error } = await extensions.dispatch(intent);
-          if (!data || error) {
-            return ToolResult.Error(error?.message ?? 'Failed to create chess game');
-          }
-
-          return ToolResult.Success(createArtifactElement(script.id));
-        },
-      }),
-      createTool(meta.id, {
-        name: 'inspect',
-        description: 'Inspect a script. Returns the artifact definition for the script',
-        caption: 'Inspecting script...',
-        schema: Schema.Struct({
-          id: ArtifactId,
+        createTool(meta.id, {
+          name: 'inspect',
+          description: 'Inspect a script. Returns the artifact definition for the script',
+          caption: 'Inspecting script...',
+          schema: Schema.Struct({
+            id: ArtifactId,
+          }),
+          execute: async ({ id }, { extensions }) => {
+            invariant(extensions?.space, 'No space');
+
+            const script = (await extensions.space.db.query(Filter.id(id)).first()) as ScriptType;
+            const { content } = await script.source.load();
+
+            return ToolResult.Success({
+              name: script.name,
+              code: content,
+            });
+          },
         }),
-        execute: async ({ id }, { extensions }) => {
-          invariant(extensions?.space, 'No space');
-
-          const script = (await extensions.space.db.query(Filter.id(id)).first()) as ScriptType;
-          const { content } = await script.source.load();
-
-          return ToolResult.Success({
-            name: script.name,
-            code: content,
-          });
-        },
-      }),
-      createTool(meta.id, {
-        name: 'update',
-        description: 'Update a script. Returns the artifact definition for the script',
-        caption: 'Updating script...',
-        schema: Schema.Struct({
-          id: ArtifactId,
-          code: Schema.String.annotations({
-            description: 'The full code of the script in JavaScript or TypeScript. Must be valid executable code.',
+        createTool(meta.id, {
+          name: 'update',
+          description: 'Update a script. Returns the artifact definition for the script',
+          caption: 'Updating script...',
+          schema: Schema.Struct({
+            id: ArtifactId,
+            code: Schema.String.annotations({
+              description: 'The full code of the script in JavaScript or TypeScript. Must be valid executable code.',
+            }),
           }),
+          execute: async ({ id, code }, { extensions }) => {
+            invariant(extensions?.space, 'No space');
+
+            const script = (await extensions.space.db.query(Filter.id(id)).first()) as ScriptType;
+            const source = await script.source.load();
+            if (!source) {
+              return ToolResult.Error('Script not found');
+            }
+
+            source.content = code;
+            await extensions.space?.db.flush();
+
+            return ToolResult.Success({
+              name: script.name,
+            });
+          },
         }),
-        execute: async ({ id, code }, { extensions }) => {
-          invariant(extensions?.space, 'No space');
-
-          const script = (await extensions.space.db.query(Filter.id(id)).first()) as ScriptType;
-          const source = await script.source.load();
-          if (!source) {
-            return ToolResult.Error('Script not found');
-          }
-
-          source.content = code;
-          await extensions.space?.db.flush();
-
-          return ToolResult.Success({
-            name: script.name,
-          });
-        },
-      }),
-    ],
-  });
-
-  return contributes(Capabilities.ArtifactDefinition, definition);
-};
+      ],
+    });
+
+    return Capability.contributes(Capabilities.ArtifactDefinition, definition);
+  }),
+);

package/src/capabilities/blueprint-definition.ts

@@ -2,29 +2,18 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Capabilities, contributes } from '@dxos/app-framework';
-import { Blueprint, Template } from '@dxos/blueprints';
-import { type FunctionDefinition } from '@dxos/functions';
-import { trim } from '@dxos/util';
+import * as Effect from 'effect/Effect';
 
-const functions: FunctionDefinition[] = [];
-const tools: string[] = [];
+import { Capability } from '@dxos/app-framework';
+import { AppCapabilities } from '@dxos/app-toolkit';
+// eslint-disable-next-line unused-imports/no-unused-imports
+import type { Blueprint } from '@dxos/compute';
 
-export default () => {
-  return [
-    contributes(Capabilities.Functions, functions),
-    contributes(
-      Capabilities.BlueprintDefinition,
-      Blueprint.make({
-        key: 'dxos.org/blueprint/script',
-        name: 'Script',
-        tools: Blueprint.toolDefinitions({ functions, tools }),
-        instructions: Template.make({
-          source: trim`
-            You can create and update scripts which contain Typescript code.
-          `,
-        }),
-      }),
-    ),
-  ];
-};
+import { ScriptBlueprint } from '#blueprints';
+
+const blueprintDefinition = Capability.makeModule<
+  [],
+  Capability.Capability<typeof AppCapabilities.BlueprintDefinition>[]
+>(() => Effect.succeed([Capability.contributes(AppCapabilities.BlueprintDefinition, ScriptBlueprint)]));
+
+export default blueprintDefinition;

package/src/capabilities/compiler.ts

@@ -10,50 +10,75 @@ import * as Schema from 'effect/Schema';
 import wasmUrl from 'esbuild-wasm/esbuild.wasm?url';
 import * as ts from 'typescript';
 
-import { contributes } from '@dxos/app-framework';
+import { Capability } from '@dxos/app-framework';
 import { initializeBundler } from '@dxos/functions-runtime/bundler';
+import { log } from '@dxos/log';
 import { trim } from '@dxos/util';
 
-import { Compiler } from '../compiler';
+import { ScriptCapabilities } from '#types';
 
-import { ScriptCapabilities } from './capabilities';
+import { Compiler } from '../compiler';
 
+// TODO(burdon): Document.
 const SCRIPT_PACKAGES_BUCKET = 'https://pub-5745ae82e450484aa28f75fc6a175935.r2.dev/dev/';
 const DECLARATION_EXTS = ['.d.ts', '.d.mts'];
 const NO_TYPES = true; // Types temopararly disabled due to compiler erorrs.
 
-export default async () => {
-  await initializeBundler({ wasmUrl });
+export default Capability.makeModule(() =>
+  Effect.gen(function* () {
+    yield* Effect.tryPromise({
+      try: () => initializeBundler({ wasmUrl }),
+      catch: (error) => new Error(`Failed to initialize bundler: ${error}`),
+    });
 
-  const runtimeModules = await Effect.runPromise(fetchRuntimeModules().pipe(Effect.provide(FetchHttpClient.layer)));
+    const runtimeModules = yield* fetchRuntimeModules().pipe(Effect.provide(FetchHttpClient.layer));
 
-  const compiler = new Compiler({
-    skipLibCheck: true,
-    moduleResolution: ts.ModuleResolutionKind.Bundler,
-    allowImportingTsExtensions: true,
-    noEmit: true,
-    strict: true,
-    esModuleInterop: true,
-    paths: Object.fromEntries(runtimeModules.map((mod) => [mod.moduleName, [`./src/${mod.filename}`]])),
-  });
+    const compiler = new Compiler({
+      target: ts.ScriptTarget.ES2022,
+      lib: ['lib.es2022.d.ts', 'lib.dom.d.ts'],
+      skipLibCheck: true,
+      moduleResolution: ts.ModuleResolutionKind.Bundler,
+      allowImportingTsExtensions: true,
+      noEmit: true,
+      strict: true,
+      esModuleInterop: true,
+      paths: Object.fromEntries(runtimeModules.map((mod: any) => [mod.moduleName, [`./src/${mod.filename}`]])),
+    });
 
-  await compiler.initialize(trim`
-    declare module 'https://*';
-    ${NO_TYPES ? '' : 'declare module "*";'}
-  `);
-  if (!NO_TYPES) {
-    for (const mod of runtimeModules) {
-      compiler.setFile(`/src/${mod.filename}`, mod.content);
+    yield* Effect.tryPromise({
+      try: () =>
+        compiler.initialize(trim`
+        declare module 'https://*';
+        ${NO_TYPES ? '' : 'declare module "*";'}
+      `),
+      catch: (error) => new Error(`Failed to initialize compiler: ${error}`),
+    });
+    if (!NO_TYPES) {
+      for (const mod of runtimeModules) {
+        compiler.setFile(`/src/${mod.filename}`, mod.content);
+      }
     }
-  }
 
-  return contributes(ScriptCapabilities.Compiler, compiler);
-};
+    return Capability.contributes(ScriptCapabilities.Compiler, compiler);
+  }),
+);
 
 const fetchRuntimeModules = Effect.fnUntraced(function* () {
+  // { key, size, contentType }
   const manifest = yield* HttpClient.get(new URL('manifest.json', SCRIPT_PACKAGES_BUCKET)).pipe(
     Effect.flatMap((_) => _.json),
-    Effect.flatMap(Schema.decodeUnknown(Schema.Struct({ files: Schema.Array(Schema.String) }))),
+    Effect.flatMap(
+      Schema.decodeUnknown(
+        Schema.Struct({
+          files: Schema.Array(
+            Schema.Struct({
+              key: Schema.String,
+            }),
+          ),
+        }),
+      ),
+    ),
+    Effect.map((manifest) => ({ ...manifest, files: manifest.files.map((f) => f.key) })),
   );
 
   const declarationFiles = manifest.files.filter((file) => DECLARATION_EXTS.some((ext) => file.endsWith(ext)));
@@ -62,17 +87,17 @@ const fetchRuntimeModules = Effect.fnUntraced(function* () {
   const modules = yield* Effect.forEach(
     declarationFiles,
     Effect.fnUntraced(
-      function* (file) {
-        const response = yield* HttpClient.get(new URL(file, SCRIPT_PACKAGES_BUCKET)).pipe(
+      function* (filename) {
+        const response = yield* HttpClient.get(new URL(filename, SCRIPT_PACKAGES_BUCKET)).pipe(
           Effect.retry(Schedule.exponential(1_000).pipe(Schedule.compose(Schedule.recurs(3)))),
         );
         const content = yield* response.text;
+        const moduleName = filename.replace(/\.d\.(ts|mts)$/, '');
         fetched++;
 
-        const moduleName = file.replace(/\.d\.(ts|mts)$/, '');
         return {
           moduleName,
-          filename: file,
+          filename,
           content,
         };
       },
@@ -80,5 +105,7 @@ const fetchRuntimeModules = Effect.fnUntraced(function* () {
     ),
     { concurrency: 20 },
   );
+
+  log.info('runtime modules', { manifest: manifest.files.length, files: declarationFiles.length, fetched });
   return modules;
 });