@dxos/plugin-script 0.8.4-main.2e9d522 → 0.8.4-main.3eb6e50203

package/src/capabilities/{artifact-definition.ts → artifact-definition/artifact-definition.ts}

@@ -2,20 +2,23 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Schema } from 'effect';
+// ISSUE(burdon): defineArtifact
+// @ts-nocheck
 
-import { createTool, ToolResult } from '@dxos/ai';
-import { Capabilities, contributes, createIntent, type PromiseIntentDispatcher } from '@dxos/app-framework';
-import { createArtifactElement, ArtifactId } from '@dxos/assistant';
+import * as Effect from 'effect/Effect';
+import * as Schema from 'effect/Schema';
+
+import { ToolResult, createTool } from '@dxos/ai';
+import { Capabilities, Capability, type PromiseIntentDispatcher, createIntent } from '@dxos/app-framework';
+import { ArtifactId, createArtifactElement } from '@dxos/assistant';
 import { defineArtifact } from '@dxos/blueprints';
 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 { type Space } from '@dxos/react-client/echo';
-import { DataType } from '@dxos/schema';
 
-import { meta } from '../meta';
+import { meta } from '../../meta';
 
 // TODO(burdon): Factor out.
 declare global {
@@ -25,14 +28,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.
@@ -52,7 +56,7 @@ export default () => {
         The description is used by AI to understand the script and its purpose.
         The description must provide cases on when the script should be used.
 
-      Schema: 
+      Schema:
         The schema is defined using a schema-DSL library called Effect Schema.
         The input schema describes the arguments that the script accepts.
         The output schema describes the result that the script produces.
@@ -73,18 +77,18 @@ export default () => {
         - Detailed output schema
 
       <apis>
-        export function defineFunction(params: { 
-          description: string, 
-          inputSchema: Schema.Schema, 
-          outputSchema: Schema.Schema, 
-          handler: (params: { event: { data: TInput } }) => Promise<TOutput> 
+        export function defineFunction(params: {
+          description: string,
+          inputSchema: Schema.Schema,
+          outputSchema: Schema.Schema,
+          handler: (params: { event: { data: TInput } }) => Promise<TOutput>
         }): FunctionDefinition
         /**
          * Effect Schema
          */
-        export const Schema; 
+        export const Schema;
 
-        // Examples: 
+        // Examples:
 
         Schema.String
         Schema.Number
@@ -102,7 +106,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
           },
@@ -110,7 +114,7 @@ export default () => {
 
         The function must return the result that matches the output schema.
       </handler_function>
-      
+
       <example>
         import { defineFunction, S } from 'dxos:functions';
 
@@ -141,89 +145,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(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(
-              Obj.make(DataType.Text, {
-                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));
-        },
-      }),
-      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.ids(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.ids(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/artifact-definition/index.ts

@@ -0,0 +1,7 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Capability } from '@dxos/app-framework';
+
+export const ArtifactDefinition = Capability.lazy('ArtifactDefinition', () => import('./artifact-definition'));

package/src/capabilities/blueprint-definition/blueprint-definition.ts

@@ -0,0 +1,24 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Capability } from '@dxos/app-framework';
+import { AppCapabilities } from '@dxos/app-toolkit';
+
+import { ScriptBlueprint } from '../../blueprints';
+
+export type BlueprintCapabilities = [
+  Capability.Capability<typeof AppCapabilities.Functions>,
+  Capability.Capability<typeof AppCapabilities.BlueprintDefinition>,
+];
+
+const blueprintDefinition = Capability.makeModule<[], BlueprintCapabilities>(() =>
+  Effect.succeed([
+    Capability.contributes(AppCapabilities.Functions, ScriptBlueprint.functions),
+    Capability.contributes(AppCapabilities.BlueprintDefinition, ScriptBlueprint.make()),
+  ]),
+);
+
+export default blueprintDefinition;

package/src/capabilities/blueprint-definition/index.ts

@@ -0,0 +1,7 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Capability } from '@dxos/app-framework';
+
+export const BlueprintDefinition = Capability.lazy('BlueprintDefinition', () => import('./blueprint-definition'));

package/src/capabilities/compiler/compiler.ts

@@ -0,0 +1,103 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as FetchHttpClient from '@effect/platform/FetchHttpClient';
+import * as HttpClient from '@effect/platform/HttpClient';
+import * as Effect from 'effect/Effect';
+import * as Schedule from 'effect/Schedule';
+import * as Schema from 'effect/Schema';
+import wasmUrl from 'esbuild-wasm/esbuild.wasm?url';
+import * as ts from 'typescript';
+
+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';
+
+// 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 Capability.makeModule(() =>
+  Effect.gen(function* () {
+    yield* Effect.tryPromise(() => initializeBundler({ wasmUrl }));
+
+    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: any) => [mod.moduleName, [`./src/${mod.filename}`]])),
+    });
+
+    yield* Effect.tryPromise(() =>
+      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);
+      }
+    }
+
+    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.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)));
+
+  let fetched = 0;
+  const modules = yield* Effect.forEach(
+    declarationFiles,
+    Effect.fnUntraced(
+      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++;
+
+        return {
+          moduleName,
+          filename,
+          content,
+        };
+      },
+      Effect.retry(Schedule.exponential(1_000).pipe(Schedule.compose(Schedule.recurs(3)))),
+    ),
+    { concurrency: 20 },
+  );
+
+  log.info('runtime modules', { manifest: manifest.files.length, files: declarationFiles.length, fetched });
+  return modules;
+});

package/src/capabilities/compiler/index.ts

@@ -0,0 +1,7 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Capability } from '@dxos/app-framework';
+
+export const Compiler = Capability.lazy('Compiler', () => import('./compiler'));

package/src/capabilities/index.ts

@@ -2,13 +2,9 @@
 // Copyright 2025 DXOS.org
 //
 
-import { lazy } from '@dxos/app-framework';
-
-export const AppGraphBuilder = lazy(() => import('./app-graph-builder'));
-export const ArtifactDefinition = lazy(() => import('./artifact-definition'));
-export const Compiler = lazy(() => import('./compiler'));
-export const IntentResolver = lazy(() => import('./intent-resolver'));
-export const ReactSurface = lazy(() => import('./react-surface'));
-export const ScriptSettings = lazy(() => import('./settings'));
-
-export * from './capabilities';
+export * from './app-graph-builder';
+export * from './blueprint-definition';
+export * from './compiler';
+export * from './operation-resolver';
+export * from './react-surface';
+export * from './settings';

package/src/capabilities/operation-resolver/index.ts

@@ -0,0 +1,7 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Capability } from '@dxos/app-framework';
+
+export const OperationResolver = Capability.lazy('OperationResolver', () => import('./operation-resolver'));

package/src/capabilities/operation-resolver/operation-resolver.ts

@@ -0,0 +1,75 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Octokit } from '@octokit/core';
+import * as Effect from 'effect/Effect';
+import * as Predicate from 'effect/Predicate';
+
+import { Capabilities, Capability } from '@dxos/app-framework';
+import { LayoutOperation } from '@dxos/app-toolkit';
+import { Script } from '@dxos/functions';
+import { Operation, OperationResolver } from '@dxos/operation';
+import { TokenManagerOperation } from '@dxos/plugin-token-manager/types';
+
+import { DEPLOYMENT_DIALOG } from '../../components';
+import { defaultScriptsForIntegration } from '../../meta';
+import { templates } from '../../templates';
+import { ScriptOperation } from '../../types';
+
+export default Capability.makeModule(
+  Effect.fnUntraced(function* () {
+    return Capability.contributes(Capabilities.OperationResolver, [
+      OperationResolver.make({
+        operation: ScriptOperation.CreateScript,
+        handler: Effect.fnUntraced(function* ({ name, gistUrl, initialTemplateId }) {
+          let source = templates[0].source;
+          let scriptName = name;
+
+          const gistId = gistUrl?.split('/').at(-1);
+          if (gistId) {
+            // TODO(wittjosiah): Capability which contributes Octokit?
+            // NOTE: AccessToken not needed to read public gists.
+            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 }) };
+        }),
+      }),
+      OperationResolver.make({
+        operation: TokenManagerOperation.AccessTokenCreated,
+        handler: 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 },
+            });
+          }
+        }),
+      }),
+    ]);
+  }),
+);

package/src/capabilities/react-surface/index.ts

@@ -0,0 +1,7 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Capability } from '@dxos/app-framework';
+
+export const ReactSurface = Capability.lazy('ReactSurface', () => import('./react-surface'));

package/src/capabilities/react-surface/react-surface.tsx

@@ -0,0 +1,119 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+import React from 'react';
+
+import { Capabilities, Capability } from '@dxos/app-framework';
+import { Surface, useAtomCapability, useSettingsState } from '@dxos/app-framework/ui';
+import { AppCapabilities } from '@dxos/app-toolkit';
+import { InvocationTraceContainer } from '@dxos/devtools';
+import { Obj } from '@dxos/echo';
+import { Script } from '@dxos/functions';
+import { getSpace } from '@dxos/react-client/echo';
+import { Layout } from '@dxos/react-ui';
+import { type AccessToken } from '@dxos/types';
+
+import {
+  DEPLOYMENT_DIALOG,
+  DeploymentDialog,
+  NotebookContainer,
+  ScriptContainer,
+  ScriptObjectSettings,
+  ScriptPluginSettings,
+  ScriptProperties,
+  TestContainer,
+} from '../../components';
+import { useCompiler } from '../../hooks';
+import { meta } from '../../meta';
+import { Notebook, ScriptCapabilities, type ScriptSettings } from '../../types';
+
+export default Capability.makeModule(() =>
+  Effect.succeed(
+    Capability.contributes(Capabilities.ReactSurface, [
+      Surface.create({
+        id: `${meta.id}/plugin-settings`,
+        role: 'article',
+        filter: (data): data is { subject: AppCapabilities.Settings } =>
+          AppCapabilities.isSettings(data.subject) && data.subject.prefix === meta.id,
+        component: ({ data: { subject } }) => {
+          const { settings, updateSettings } = useSettingsState<ScriptSettings>(subject.atom);
+          return <ScriptPluginSettings settings={settings} onSettingsChange={updateSettings} />;
+        },
+      }),
+      Surface.create({
+        id: `${meta.id}/script/article`,
+        role: ['article', 'section'],
+        filter: (data): data is { subject: Script.Script } => Obj.instanceOf(Script.Script, data.subject),
+        component: ({ data, role }) => {
+          const compiler = useCompiler();
+          const settings = useAtomCapability(ScriptCapabilities.Settings);
+          // TODO(wittjosiah): Why? The editor should be allow to render even if the environment is not ready.
+          if (!compiler?.environment) {
+            return null;
+          }
+
+          return <ScriptContainer role={role} subject={data.subject} settings={settings} env={compiler?.environment} />;
+        },
+      }),
+      Surface.create({
+        id: `${meta.id}/notebook/article`,
+        role: 'article',
+        filter: (data): data is { subject: Notebook.Notebook } => Obj.instanceOf(Notebook.Notebook, data.subject),
+        component: ({ data, role }) => {
+          const compiler = useCompiler();
+          return <NotebookContainer role={role} subject={data.subject} env={compiler?.environment} />;
+        },
+      }),
+      // TODO(burdon): Standardize PluginSettings vs ObjectSettings.
+      // TODO(burdon): Why is ScriptProperties different from ScriptObjectSettings?
+      Surface.create({
+        id: `${meta.id}/companion/base-settings`,
+        role: 'base-object-settings',
+        filter: (data): data is { subject: Script.Script } => Obj.instanceOf(Script.Script, data.subject),
+        component: ({ data }) => <ScriptProperties object={data.subject} />,
+      }),
+      Surface.create({
+        id: `${meta.id}/companion/settings`,
+        role: 'object-settings',
+        filter: (data): data is { subject: Script.Script } => Obj.instanceOf(Script.Script, data.subject),
+        component: ({ data }) => <ScriptObjectSettings object={data.subject} />,
+      }),
+      Surface.create({
+        id: `${meta.id}/companion/execute`,
+        role: 'article',
+        filter: (data): data is { companionTo: Script.Script } =>
+          Obj.instanceOf(Script.Script, data.companionTo) && data.subject === 'execute',
+        component: ({ data, role }) => <TestContainer script={data.companionTo} role={role} />,
+      }),
+      Surface.create({
+        id: `${meta.id}/companion/logs`,
+        role: 'article',
+        filter: (data): data is { companionTo: Script.Script } =>
+          Obj.instanceOf(Script.Script, data.companionTo) && data.subject === 'logs',
+        component: ({ data, role }) => {
+          const space = getSpace(data.companionTo);
+          const queueDxn = space?.properties.invocationTraceQueue?.dxn;
+          return (
+            <Layout.Main role={role}>
+              <InvocationTraceContainer
+                db={space?.db}
+                queueDxn={queueDxn}
+                target={data.companionTo}
+                detailAxis='block'
+              />
+            </Layout.Main>
+          );
+        },
+      }),
+      Surface.create({
+        id: DEPLOYMENT_DIALOG,
+        role: 'dialog',
+        filter: (data): data is { props: { accessToken: AccessToken.AccessToken; scriptTemplates: any } } =>
+          data.component === DEPLOYMENT_DIALOG,
+        component: ({ data }) => <DeploymentDialog {...data.props} />,
+      }),
+    ]),
+  ),
+);

package/src/capabilities/settings/index.ts

@@ -0,0 +1,7 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Capability } from '@dxos/app-framework';
+
+export const ScriptSettings = Capability.lazy('ScriptSettings', () => import('./settings'));