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

package/src/notebook/{notebook.ts → compute-graph.ts}

@@ -2,46 +2,88 @@
 // Copyright 2025 DXOS.org
 //
 
-import { type Signal, signal } from '@preact/signals-core';
+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';
 
 /**
  * Compute graph that evaluates the notebook cells.
  */
+// TODO(burdon): Reconcile with @dxos/conductor.
 export class ComputeGraph {
   private readonly _parser = new VirtualTypeScriptParser();
 
-  private _expressions = signal<Record<string, ParsedExpression>>({});
-  private _values = signal<Record<string, any>>({});
+  private _expressionsAtom = Atom.make<Record<string, ParsedExpression>>({});
+  private _valuesByCellIdAtom = Atom.make<Record<string, any>>({});
+  private _valuesByNameAtom = Atom.make<Record<string, any>>({});
 
-  constructor(private readonly _notebook: Notebook.Notebook) {}
+  constructor(
+    private readonly _notebook: Notebook.Notebook,
+    private readonly _registry: Registry.Registry,
+  ) {}
 
   /**
-   * Parsed expressions by cell ID.
+   * Atom for parsed expressions by cell ID.
    */
-  get expressions(): Signal<Record<string, ParsedExpression>> {
-    return this._expressions;
+  get expressions(): Atom.Atom<Record<string, ParsedExpression>> {
+    return this._expressionsAtom;
   }
 
   /**
-   * Computed values by cell ID.
+   * Get current expressions by cell ID.
    */
-  get values(): Signal<Record<string, any>> {
-    return this._values;
+  getExpressions(): Record<string, ParsedExpression> {
+    return this._registry.get(this._expressionsAtom);
+  }
+
+  /**
+   * Atom for computed values by cell ID.
+   */
+  get values(): Atom.Atom<Record<string, any>> {
+    return this._valuesByCellIdAtom;
+  }
+
+  /**
+   * Get computed values by cell ID.
+   */
+  getValues(): Record<string, any> {
+    return this._registry.get(this._valuesByCellIdAtom);
+  }
+
+  /**
+   * Atom for computed values by name.
+   */
+  get valuesByName(): Atom.Atom<Record<string, any>> {
+    return this._valuesByNameAtom;
+  }
+
+  /**
+   * Get current values by name.
+   */
+  getValuesByName(): Record<string, any> {
+    return this._registry.get(this._valuesByNameAtom);
+  }
+
+  /**
+   * Get computed value by cell ID.
+   */
+  getValue(cellId: string): any {
+    return this._registry.get(this._valuesByCellIdAtom)[cellId];
   }
 
   /**
    * Compute values.
    */
-  evaluate() {
+  async evaluate() {
     // Parse expressions.
     const { expressions, dependencyGraph } = this.parse();
-    this._values.value = {};
+    this._registry.set(this._valuesByCellIdAtom, {});
+    this._registry.set(this._valuesByNameAtom, {});
 
     // Create a map of cell IDs to expressions for easy lookup.
     const cellExpressions = new Map<string, ParsedExpression>();
@@ -64,7 +106,7 @@ export class ComputeGraph {
         continue;
       }
 
-      const cellSource = this._notebook.cells.find((cell) => cell.id === cellId)?.script.target?.content;
+      const cellSource = this._notebook.cells.find((cell) => cell.id === cellId)?.source?.target?.content;
       if (!cellSource) {
         log.error('no source for cell', { cellId });
         continue;
@@ -89,7 +131,7 @@ export class ComputeGraph {
               rhs = rhs.slice(0, -1).trim();
             }
 
-            const result = this.evalScript(rhs, valuesByName);
+            const result = await this.eval(rhs, valuesByName);
             valuesByName[expr.name] = result;
             if (typeof result !== 'function') {
               valuesByCellId[cellId] = result;
@@ -97,35 +139,43 @@ export class ComputeGraph {
           }
         } else {
           // For expressions without assignment, just evaluate.
-          const result = this.evalScript(cellSource, valuesByName);
+          const result = await this.eval(cellSource, valuesByName);
           valuesByCellId[cellId] = result;
         }
       } catch (error) {
+        // TODO(burdon): Set error state.
         log.error('error evaluating cell', { cellId, error });
       }
     }
 
-    this._values.value = valuesByCellId;
+    this._registry.set(this._valuesByCellIdAtom, valuesByCellId);
+    this._registry.set(this._valuesByNameAtom, valuesByName);
     return valuesByCellId;
   }
 
+  private async eval(source: string, values: Record<string, any>) {
+    return evalScript(source, values);
+  }
+
   /**
    * Parse expressions.
    */
   parse() {
-    const expressions = this._notebook.cells.reduce<Record<string, ParsedExpression>>((acc, cell) => {
-      const text = cell.script.target?.content.trim();
-      if (text) {
-        const parsed = this._parser.parseExpression(text);
-        acc[cell.id] = parsed;
-      }
+    const expressions = this._notebook.cells
+      .filter((cell) => cell.type === 'script')
+      .reduce<Record<string, ParsedExpression>>((acc, cell) => {
+        const text = cell.source?.target?.content.trim();
+        if (text) {
+          const parsed = this._parser.parseExpression(text);
+          acc[cell.id] = parsed;
+        }
 
-      return acc;
-    }, {});
+        return acc;
+      }, {});
 
     // Build dependency graph.
     const dependencyGraph = this.buildDependencyGraph(expressions);
-    this._expressions.value = expressions;
+    this._registry.set(this._expressionsAtom, expressions);
     return { expressions, dependencyGraph };
   }
 
@@ -177,12 +227,4 @@ export class ComputeGraph {
 
     return graph;
   }
-
-  /**
-   * Evaluate the script (with dependencies as arguments).
-   */
-  private evalScript(code: string, deps: Record<string, any> = {}) {
-    // eslint-disable-next-line @typescript-eslint/no-implied-eval
-    return new Function(...Object.keys(deps), 'return ' + code)(...Object.values(deps));
-  }
 }

package/src/notebook/eval.ts

@@ -0,0 +1,105 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { trim } from '@dxos/util';
+
+/**
+ * Evaluate the script (with dependencies as arguments).
+ */
+export const evalScript = async (code: string, deps: Record<string, any> = {}) => {
+  // Create a sandboxed environment that blocks access to window and document.
+  const sandbox = {
+    ...deps,
+
+    // Block access to global objects.
+    console: undefined,
+    document: undefined,
+    global: undefined,
+    globalThis: undefined,
+    self: undefined,
+    window: undefined,
+
+    // Allow some safe globals.
+    Array,
+    Boolean,
+    Date,
+    Error,
+    JSON,
+    Map,
+    Math,
+    Number,
+    Object,
+    Promise,
+    RegExp,
+    Set,
+    String,
+
+    // Functions.
+    isFinite,
+    isNaN,
+    parseFloat,
+    parseInt,
+
+    // Note: undefined and null are not included as they are keywords, not variables.
+  };
+
+  // Create function with all sandbox keys as parameters.
+  const sandboxKeys = Object.keys(sandbox);
+  const sandboxValues = Object.values(sandbox);
+
+  // eslint-disable-next-line @typescript-eslint/no-implied-eval
+  const fn = new Function(
+    ...sandboxKeys,
+    trim`
+      'use strict';
+      return ${code};
+    `,
+  );
+
+  return fn(...sandboxValues);
+};
+
+/**
+ * Globals.
+ */
+export const builtIns = new Set([
+  // Types.
+  'Array',
+  'Date',
+  'Error',
+  'JSON',
+  'Map',
+  'Math',
+  'Number',
+  'Object',
+  'Promise',
+  'RegExp',
+  'Set',
+  'String',
+
+  // Functions.
+  'isFinite',
+  'isNaN',
+  'parseFloat',
+  'parseInt',
+]);
+
+/**
+ * Default system definitions.
+ */
+export const systemDefinitions = trim`
+  interface Array<T> { length: number; [n: number]: T; }
+  interface Boolean {}
+  interface Function {}
+  interface IArguments {}
+  interface Number {}
+  interface Object {}
+  interface RegExp {}
+  interface String { length: number; }
+
+  interface CallableFunction extends Function {}
+  interface NewableFunction extends Function {}
+
+  declare var console: { log(...args: any[]): void };
+`;

package/src/notebook/index.ts

@@ -2,4 +2,4 @@
 // Copyright 2025 DXOS.org
 //
 
-export * from './notebook';
+export * from './compute-graph';

package/src/notebook/vfs-parser.ts

@@ -6,7 +6,18 @@ import { createSystem, createVirtualTypeScriptEnvironment } from '@typescript/vf
 import ts from 'typescript';
 
 import { invariant } from '@dxos/invariant';
-import { trim } from '@dxos/util';
+
+import { builtIns, systemDefinitions } from './eval';
+
+/**
+ * Default system definitions.
+ */
+const systemFiles: VirtualFile[] = [
+  {
+    filename: '/lib.d.ts',
+    content: systemDefinitions,
+  },
+];
 
 export type ParsedExpression = {
   name?: string;
@@ -31,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,
@@ -50,7 +62,7 @@ export class VirtualTypeScriptParser {
     // If no declarations found, check for standalone expression references.
     if (analysis.length === 0) {
       const sourcefilename = '/temp.ts';
-      const env = this.createEnvironment([{ filename: sourcefilename, content: input }, ...systemFiles]);
+      const env = this.createEnvironment([{ filename: sourcefilename, content: input }]);
       const sourceFile = env.getSourceFile(sourcefilename);
       const typeChecker = env.languageService.getProgram()?.getTypeChecker();
 
@@ -73,14 +85,16 @@ export class VirtualTypeScriptParser {
    * Analyze multiple files with full type information.
    */
   analyzeFiles(files: VirtualFile[]): ParsedExpression[] {
-    const env = this.createEnvironment([...files, ...systemFiles]);
+    const env = this.createEnvironment(files);
     const results: ParsedExpression[] = [];
     const typeChecker = env.languageService.getProgram()?.getTypeChecker();
 
     // 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);
@@ -96,7 +110,7 @@ export class VirtualTypeScriptParser {
     const results: ParsedExpression[] = [];
 
     const visit = (node: ts.Node) => {
-      // Function declarations
+      // Function declarations.
       if (ts.isFunctionDeclaration(node) && node.name) {
         const symbol = typeChecker.getSymbolAtLocation(node.name);
         const type = symbol && typeChecker.getTypeOfSymbolAtLocation(symbol, node);
@@ -123,7 +137,7 @@ export class VirtualTypeScriptParser {
             let returnType: string | undefined;
             let value: any;
 
-            // Get the type string
+            // Get the type string.
             const typeString = type ? typeChecker.typeToString(type) : 'any';
 
             // Check if it's a function.
@@ -146,7 +160,7 @@ export class VirtualTypeScriptParser {
               }
             }
 
-            // Find references in the initializer only
+            // Find references in the initializer only.
             const refs = declaration.initializer
               ? this.findReferences(declaration.initializer, sourceFile, typeChecker)
               : [];
@@ -164,7 +178,7 @@ export class VirtualTypeScriptParser {
         });
       }
 
-      // Class declarations
+      // Class declarations.
       else if (ts.isClassDeclaration(node) && node.name) {
         results.push({
           name: node.name.text,
@@ -196,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(),
@@ -212,42 +228,42 @@ export class VirtualTypeScriptParser {
     const localSymbols = new Set<string>();
 
     // First, collect local symbols (parameters, local variables).
-    const collectLocalSymbols = (n: ts.Node) => {
-      if (ts.isFunctionDeclaration(n) || ts.isArrowFunction(n) || ts.isFunctionExpression(n)) {
-        n.parameters.forEach((param) => {
+    const collectLocalSymbols = (node: ts.Node) => {
+      if (ts.isFunctionDeclaration(node) || ts.isArrowFunction(node) || ts.isFunctionExpression(node)) {
+        node.parameters.forEach((param) => {
           if (ts.isIdentifier(param.name)) {
             localSymbols.add(param.name.text);
           }
         });
       }
 
-      if (ts.isVariableDeclaration(n) && ts.isIdentifier(n.name)) {
-        localSymbols.add(n.name.text);
+      if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name)) {
+        localSymbols.add(node.name.text);
       }
 
-      ts.forEachChild(n, collectLocalSymbols);
+      ts.forEachChild(node, collectLocalSymbols);
     };
 
     collectLocalSymbols(node);
 
     // Then find all identifier references.
-    const findRefs = (n: ts.Node) => {
-      if (ts.isIdentifier(n)) {
-        // Skip if it's a local symbol
-        if (!localSymbols.has(n.text)) {
+    const findRefs = (node: ts.Node) => {
+      if (ts.isIdentifier(node)) {
+        // Skip if it's a local symbol.
+        if (!localSymbols.has(node.text)) {
           // Check if it's a reference (not a declaration).
-          const parent = n.parent;
+          const parent = node.parent;
           const isDeclaration =
-            (ts.isVariableDeclaration(parent) && parent.name === n) ||
-            (ts.isFunctionDeclaration(parent) && parent.name === n) ||
-            (ts.isParameter(parent) && parent.name === n);
+            (ts.isVariableDeclaration(parent) && parent.name === node) ||
+            (ts.isFunctionDeclaration(parent) && parent.name === node) ||
+            (ts.isParameter(parent) && parent.name === node);
 
-          if (!isDeclaration && !this.isBuiltIn(n.text)) {
-            references.add(n.text);
+          if (!isDeclaration && !this.isBuiltIn(node.text)) {
+            references.add(node.text);
           }
         }
       }
-      ts.forEachChild(n, findRefs);
+      ts.forEachChild(node, findRefs);
     };
 
     findRefs(node);
@@ -274,7 +290,7 @@ export class VirtualTypeScriptParser {
           const type = typeChecker.getTypeAtLocation(expr.right);
           const typeString = typeChecker.typeToString(type);
 
-          // Get the literal value if it's a literal
+          // Get the literal value if it's a literal.
           let value: any;
           if (ts.isNumericLiteral(expr.right)) {
             value = Number(expr.right.text);
@@ -282,7 +298,7 @@ export class VirtualTypeScriptParser {
             value = expr.right.text;
           }
 
-          // Find references in the right-hand side
+          // Find references in the right-hand side.
           const references = this.findReferences(expr.right, sourceFile, typeChecker);
 
           result = {
@@ -336,15 +352,17 @@ export class VirtualTypeScriptParser {
   }
 
   protected createEnvironment(files: VirtualFile[]) {
+    const allFiles = [...systemFiles, ...files];
+
     const fileMap = new Map<string, string>();
-    files.forEach(({ filename, content }) => {
+    allFiles.forEach(({ filename, content }) => {
       fileMap.set(filename, content);
     });
 
     const system = createSystem(fileMap);
     return createVirtualTypeScriptEnvironment(
       system,
-      files.map(({ filename }) => filename),
+      allFiles.map(({ filename }) => filename),
       ts,
       this.compilerOptions,
     );
@@ -359,7 +377,7 @@ export class NotebookVirtualParser extends VirtualTypeScriptParser {
    * Analyze notebook cells with full type checking.
    */
   analyzeNotebook(cells: Array<{ id: string; code: string }>) {
-    // Create cumulative environment where each cell can see previous cells
+    // Create cumulative environment where each cell can see previous cells.
     const cumulativeCode: string[] = [];
     const cellAnalysis: Map<
       string,
@@ -390,7 +408,7 @@ export class NotebookVirtualParser extends VirtualTypeScriptParser {
       });
 
       // Create environment.
-      const env = this.createEnvironment([...files, ...systemFiles]);
+      const env = this.createEnvironment(files);
 
       // Get diagnostics (errors).
       const diagnostics = env.languageService.getSemanticDiagnostics(filename);
@@ -416,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);
+            }
           });
         }
 
@@ -436,55 +456,3 @@ export class NotebookVirtualParser extends VirtualTypeScriptParser {
     return cellAnalysis;
   }
 }
-
-/**
- * Globals.
- */
-const builtIns = new Set([
-  // Types.
-  'Array',
-  'Date',
-  'Error',
-  'JSON',
-  'Map',
-  'Math',
-  'Number',
-  'Promise',
-  'Object',
-  'RegExp',
-  'Set',
-  'String',
-
-  // Functions.
-  'console',
-  'document',
-  'global',
-  'isFinite',
-  'isNaN',
-  'parseFloat',
-  'parseInt',
-  'process',
-  'window',
-]);
-
-/**
- * Default system definitions.
- */
-const systemFiles: VirtualFile[] = [
-  {
-    filename: '/lib.d.ts',
-    content: trim`
-      interface Array<T> { length: number; [n: number]: T; }
-      interface Boolean {}
-      interface Function {}
-      interface IArguments {}
-      interface Number {}
-      interface Object {}
-      interface RegExp {}
-      interface String { length: number; }
-      interface CallableFunction extends Function {}
-      interface NewableFunction extends Function {}
-      declare var console: { log(...args: any[]): void };
-    `,
-  },
-];

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,7 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { OperationHandlerSet } from '@dxos/compute';
+
+export const ScriptOperationHandlerSet = OperationHandlerSet.lazy(() => 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';