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

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

@@ -1,227 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-// 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, 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 { meta } from '../../meta';
-
-// TODO(burdon): Factor out.
-declare global {
-  interface ToolContextExtensions {
-    space?: Space;
-    dispatch?: PromiseIntentDispatcher;
-  }
-}
-
-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.
-      Scripts are short code pieces of executable code that can be used to perform computations, integrate with external systems, and perform automated tasks.
-      Each script must follow as strict shape for the definition but the body can contain any valid executable code.
-      Scripts are written in JavaScript or TypeScript.
-      Each script must define an input schema and output schema.
-      Each script must have its own detailed description.
-
-      Important: You cannot execute scripts. Scripts are only available as tools after the user deploys them. You must only call the available tools.
-
-      Description:
-        The description is a detailed description of the script.
-        It is used to describe the script's purpose, input, and output.
-        The description is used to generate the script's documentation.
-        The description is also goes into the script metadata.
-        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:
-        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.
-        The schema is used to validate the script's input and output.
-        The schema is also goes into the script metadata.
-        The properties in the schema must have valid descriptions.
-        The input and output schemas must both be a struct of fields.
-
-      Restricts:
-        The scripts can only import code from "dxos:functions" module. No other modules are allowed.
-        Some web APIs are available - like fetch.
-
-      Reasoning:
-        Before writing a script, synthesize the following information:
-        - Description
-        - What APIs will be used.
-        - Detailed input schema
-        - Detailed output schema
-
-      <apis>
-        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;
-
-        // Examples:
-
-        Schema.String
-        Schema.Number
-        Schema.Boolean
-        Schema.Struct({
-          from: Schema.String.annotations({ description: 'The source currency' }),
-          to: Schema.String.annotations({ description: 'The target currency' }),
-        })
-        Schema.Array(Schema.String)
-        Schema.Union(Schema.String, Schema.Number)
-        Schema.optional(Schema.String)
-        Schema.String.annotations({ description: 'The source currency' })
-      </apis>
-
-      <handler_function>
-        Async function that takes the argument in the form of:
-
-        type HandlerFunctionProp = {
-          event: {
-            data: T // The input schema
-          },
-        }
-
-        The function must return the result that matches the output schema.
-      </handler_function>
-
-      <example>
-        import { defineFunction, S } from 'dxos:functions';
-
-        export default defineFunction({
-          description: 'Returns the exchange rate between two currencies.',
-
-          inputSchema: Schema.Struct({
-            from: Schema.String.annotations({ description: 'The source currency' }),
-            to: Schema.String.annotations({ description: 'The target currency' }),
-          }),
-
-          outputSchema: Schema.Struct({
-            rate: Schema.String.annotations({ description: 'The exchange rate' }),
-          }),
-
-          handler: async ({
-            event: {
-              data: { from, to },
-            },
-          }: any) => {
-            const res = await fetch(\`https://free.ratesdb.com/v1/rates?from=\${from}&to=\${to}\`);
-            const {
-              data: { rates },
-            } = await res.json();
-
-            return { rate: rates[to].toString() };
-          },
-        });
-      </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.',
-            }),
-          }),
-          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,
-          }),
-          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.',
-            }),
-          }),
-          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 Capability.contributes(Capabilities.ArtifactDefinition, definition);
-  }),
-);

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

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

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

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

package/src/capabilities/compiler/index.ts

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

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

@@ -1,7 +0,0 @@
-//
-// 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

@@ -1,75 +0,0 @@
-//
-// 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 '../../constants';
-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

@@ -1,7 +0,0 @@
-//
-// 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

@@ -1,121 +0,0 @@
-//
-// 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 { Panel } from '@dxos/react-ui';
-import { type AccessToken } from '@dxos/types';
-
-import { DEPLOYMENT_DIALOG } from '../../constants';
-import {
-  DeploymentDialog,
-  NotebookContainer,
-  ScriptContainer,
-  ScriptObjectSettings,
-  ScriptPluginSettings,
-  ScriptProperties,
-  TestContainer,
-} from '../../containers';
-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 (
-            <Panel.Root role={role}>
-              <Panel.Content asChild>
-                <InvocationTraceContainer
-                  db={space?.db}
-                  queueDxn={queueDxn}
-                  target={data.companionTo}
-                  detailAxis='block'
-                />
-              </Panel.Content>
-            </Panel.Root>
-          );
-        },
-      }),
-      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

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

package/src/components/FrameContainer/FrameContainer.tsx

@@ -1,85 +0,0 @@
-//
-// Copyright 2023 DXOS.org
-//
-
-import React, { useEffect, useRef } from 'react';
-
-import { clientServiceBundle } from '@dxos/client-protocol';
-import { type BundleResult } from '@dxos/functions-runtime/bundler';
-import { invariant } from '@dxos/invariant';
-import { log } from '@dxos/log';
-import { useClient } from '@dxos/react-client';
-import { createProtoRpcPeer } from '@dxos/rpc';
-import { createIFramePort } from '@dxos/rpc-tunnel';
-import { mx } from '@dxos/ui-theme';
-
-export type FrameContainerProps = {
-  containerUrl: string;
-  result: BundleResult;
-  debug?: boolean;
-};
-
-/**
- * IFrame container for the compiled script.
- */
-export const FrameContainer = ({ containerUrl, result, debug = true }: FrameContainerProps) => {
-  const client = useClient();
-  const iframeRef = useRef<HTMLIFrameElement>(null);
-  useEffect(() => {
-    if (iframeRef.current) {
-      // Connect iframe to client.
-      const rpc = createProtoRpcPeer({
-        exposed: clientServiceBundle,
-        handlers: (client as any)._services.services, // TODO(burdon): Remove cast?
-        port: createIFramePort({
-          channel: 'frame',
-          iframe: iframeRef.current,
-          origin: '*',
-        }),
-      });
-
-      rpc.open().catch((e) => log.catch(e));
-      return () => {
-        rpc.close().catch((e) => log.catch(e));
-      };
-    }
-  }, [iframeRef]);
-
-  // Encodes compiled code via URL.
-  invariant(result.sourceHash, 'Source hash is required.');
-  const sourceHash = Buffer.from(result.sourceHash).toString('hex');
-  const src =
-    'bundle' in result
-      ? `${containerUrl}?ts=${sourceHash}#code=${encodeURIComponent(new TextDecoder().decode(Object.values(result.bundle as any)[0] as Uint8Array))}`
-      : undefined;
-
-  return (
-    <>
-      <iframe ref={iframeRef} sandbox='allow-scripts' src={src} style={{ width: '100%', height: '100%' }} />
-
-      {debug && (
-        <div className='relative'>
-          <div
-            className={mx(
-              'flex absolute right-2 bottom-2 w-[30rem] h-[200px] bg-base-surface ring rounded-sm',
-              'z-20 overflow-x-hidden overflow-y-auto',
-            )}
-          >
-            <pre className='text-xs whitespace-break-spaces break-all p-2'>
-              {JSON.stringify(
-                {
-                  timestamp: result.timestamp,
-                  sourceHash,
-                  error: 'error' in result ? result.error : undefined,
-                  src,
-                },
-                undefined,
-                2,
-              )}
-            </pre>
-          </div>
-        </div>
-      )}
-    </>
-  );
-};

package/src/components/FrameContainer/frame.html

@@ -1,25 +0,0 @@
-<html>
-  <head>
-    <script src="https://cdn.tailwindcss.com"></script>
-    <script type="importmap">
-      __IMPORT_MAP__
-    </script>
-
-    <script type="module">
-      import RefreshRuntime from '/@react-refresh';
-      RefreshRuntime.injectIntoGlobalHook(window);
-      window.$RefreshReg$ = () => {};
-      window.$RefreshSig$ = () => (type) => type;
-      window.__vite_plugin_react_preamble_installed__ = true;
-    </script>
-    <script type="module" src="/@vite/client"></script>
-  </head>
-  <body>
-    <div id="root"></div>
-
-    <!-- Prevent vite from compiling this. -->
-    <script type="module">
-      eval('import("@frame/main")');
-    </script>
-  </body>
-</html>

package/src/components/FrameContainer/frame.tsx

@@ -1,51 +0,0 @@
-//
-// Copyright 2023 DXOS.org
-//
-
-import React from 'react';
-import { createRoot } from 'react-dom/client';
-
-import { ClientProvider } from '@dxos/react-client';
-
-const init = async (f: () => Promise<Record<string, any>>) =>
-  Object.entries(await f()).reduce<Record<string, any>>((map, [key, module]) => {
-    map[key] = module;
-    return map;
-  }, {});
-
-const main = async () => {
-  const { ClientServicesProxy } = await import('@dxos/react-client');
-  const { createIFramePort } = await import('@dxos/rpc-tunnel');
-
-  // @ts-ignore
-  window.__DXOS_SANDBOX_MODULES__ = await init(async () => ({
-    // prettier-ignore
-    'react': await import('react'),
-    'react-dom/client': await import('react-dom/client'),
-    '@dxos/client': await import('@dxos/client'),
-    '@dxos/react-client': await import('@dxos/react-client'),
-    '@dxos/react-client/echo': await import('@dxos/react-client/echo'),
-    '@dxos/plugin-explorer': await import('@dxos/plugin-explorer'),
-  }));
-
-  // eslint-disable-next-line @typescript-eslint/no-implied-eval
-  const Component = Function('React', "return React.lazy(() => import('@frame/bundle'))")(React);
-
-  const services = new ClientServicesProxy(
-    createIFramePort({
-      channel: 'frame',
-      origin: '*',
-    }),
-  );
-
-  // TODO(burdon): Error handling.
-  createRoot(document.getElementById('root')!).render(
-    <div className='flex fixed inset-0'>
-      <ClientProvider services={() => services}>
-        <Component />
-      </ClientProvider>
-    </div>,
-  );
-};
-
-void main();

package/src/components/FrameContainer/index.ts

@@ -1,5 +0,0 @@
-//
-// Copyright 2023 DXOS.org
-//
-
-export * from './FrameContainer';