@dxos/plugin-script 0.7.5-main.9d26e3a → 0.7.5-main.b19bfc8

package/src/templates/chess.ts

@@ -1,41 +1,48 @@
-//
-// Copyright 2024 DXOS.org
-//
-
+// @ts-ignore
+import { defineFunction, S } from 'dxos:functions';
 // @ts-ignore
 import { Chess } from 'https://esm.sh/chess.js@0.13.1';
 
-/**
- * Plays a random move in a chess game.
- */
-export default async ({
-  event: {
-    data: { request },
-  },
-  context: { space },
-}: any) => {
-  const {
-    data: {
-      objects: [gameId],
-      player = 'b',
-    },
-  } = await request.json();
+export default defineFunction({
+  description: 'Plays a random move in a chess game.',
 
-  const { pgn } = await space.crud.query({ id: gameId }).first();
-  const game = new Chess();
-  game.load_pgn(pgn);
-  if (game.turn() !== player) {
-    return new Response('Invalid turn', { status: 409 });
-  }
+  inputSchema: S.Struct({
+    changedObjectId: S.String.annotations({
+      description: 'The objects to play the game on.',
+    }),
+    player: S.optional(S.Literal('w', 'b')).annotations({
+      description: 'The player to play the game as.',
+    }),
+  }),
 
-  const moves = game.moves();
-  const move = moves[Math.floor(Math.random() * moves.length)];
-  if (!move) {
-    return new Response('No legal moves', { status: 406 });
-  }
+  outputSchema: S.Struct({
+    state: S.String.annotations({
+      description: 'The state of the game as an ASCII art board.',
+    }),
+  }),
 
-  game.move(move);
-  const newPgn = game.pgn();
-  await space.crud.update({ id: gameId }, { pgn: newPgn });
-  return new Response(game.ascii());
-};
+  handler: async ({
+    event: {
+      data: { changedObjectId, player = 'b' },
+    },
+    context: { space },
+  }: any) => {
+    const { pgn } = await space.db.query({ id: changedObjectId }).first();
+    const game = new Chess();
+    game.load_pgn(pgn);
+    if (game.turn() !== player) {
+      return new Response('Invalid turn', { status: 409 });
+    }
+
+    const moves = game.moves();
+    const move = moves[Math.floor(Math.random() * moves.length)];
+    if (!move) {
+      return new Response('No legal moves', { status: 406 });
+    }
+
+    game.move(move);
+    const newPgn = game.pgn();
+    await space.db.update({ id: changedObjectId }, { pgn: newPgn, fen: game.fen() });
+    return { state: game.ascii() };
+  },
+});

package/src/templates/discord.ts

@@ -0,0 +1,103 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+// @ts-ignore
+import { createStatic, EchoObject, defineFunction, DXN, Filter, ObjectId, S } from 'dxos:functions';
+import {
+  FetchHttpClient,
+  // @ts-ignore
+} from 'https://esm.sh/@effect/platform@0.77.2?deps=effect@3.13.3';
+// @ts-ignore
+import { DiscordConfig, DiscordREST, DiscordRESTMemoryLive } from 'https://esm.sh/dfx@0.113.0?deps=effect@3.13.3';
+// @ts-ignore
+import { Effect, Config, Redacted, Ref } from 'https://esm.sh/effect@3.13.3';
+
+const MessageSchema = S.Struct({
+  id: S.String,
+  foreignId: S.Any, // bigint?
+  from: S.String,
+  created: S.String,
+  content: S.String,
+}).pipe(EchoObject('example.com/type/Message', '0.1.0'));
+
+const DEFAULT_AFTER = 1704067200; // 2024-01-01
+
+const generateSnowflake = (unixTimestamp: number): bigint => {
+  const discordEpoch = 1420070400000n; // Discord Epoch (ms)
+  return (BigInt(unixTimestamp * 1000) - discordEpoch) << 22n;
+};
+
+export default defineFunction({
+  inputSchema: S.Struct({
+    // TODO(wittjosiah): Remove. This is used to provide a terminal for a cron trigger.
+    tick: S.optional(S.String),
+    channelId: S.String,
+    after: S.optional(S.Number),
+    pageSize: S.optional(S.Number),
+    queueId: S.String,
+  }),
+
+  outputSchema: S.Struct({
+    newMessages: S.Number,
+  }),
+
+  handler: ({
+    event: {
+      data: { channelId, queueId, after = DEFAULT_AFTER, pageSize = 5 },
+    },
+    context: { space },
+  }: any) =>
+    Effect.gen(function* () {
+      const { token } = yield* Effect.tryPromise(() =>
+        space.db.query(Filter.typename('dxos.org/type/AccessToken', { source: 'discord.com' })).first(),
+      );
+      const { objects } = yield* Effect.tryPromise(() => space.queues.queryQueue(DXN.parse(queueId)));
+      const backfill = objects.length === 0;
+      const newMessages = yield* Ref.make(0);
+      const lastMessage = yield* Ref.make(objects.at(-1));
+
+      const enqueueMessages = Effect.gen(function* () {
+        const rest = yield* DiscordREST;
+
+        while (true) {
+          const last = yield* Ref.get(lastMessage);
+          const options = {
+            after: backfill && !last ? `${generateSnowflake(after)}` : last?.foreignId,
+            limit: pageSize,
+          };
+          const messages = yield* rest.getChannelMessages(channelId, options).pipe((res: any) => res.json);
+          const queueMessages = messages
+            .map((message: any) =>
+              createStatic(MessageSchema, {
+                id: ObjectId.random(),
+                foreignId: message.id,
+                from: message.author.username,
+                created: message.timestamp,
+                content: message.content,
+              }),
+            )
+            .toReversed();
+          if (queueMessages.length > 0) {
+            yield* Effect.tryPromise(() => space.queues.insertIntoQueue(DXN.parse(queueId), queueMessages));
+            yield* Ref.update(newMessages, (n: any) => n + queueMessages.length);
+            yield* Ref.update(lastMessage, (m: any) => queueMessages.at(-1));
+          }
+          if (messages.length < pageSize) {
+            break;
+          }
+        }
+      }).pipe(
+        Effect.provide(DiscordRESTMemoryLive),
+        Effect.provide(
+          DiscordConfig.layerConfig({
+            token: Config.succeed(Redacted.make(token)),
+          }),
+        ),
+        Effect.provide(FetchHttpClient.layer),
+      );
+
+      yield* enqueueMessages;
+      return { newMessages: yield* Ref.get(newMessages) };
+    }),
+});

package/src/templates/echo.ts

@@ -11,5 +11,9 @@ export default async ({
   },
 }: any) => {
   const data = await request.json();
-  return new Response(JSON.stringify(data ?? {}), { headers: { 'Content-Type': 'application/json' } });
+  return new Response(JSON.stringify(data ?? {}), {
+    headers: {
+      'Content-Type': 'application/json',
+    },
+  });
 };

package/src/templates/email.ts

@@ -3,7 +3,8 @@
 //
 
 /**
- * Stores a message into ECHO Mailbox object.
+ * Appends a message to the end of a Document configured through a trigger.
+ * Trigger must have a targetDocumentId field set in Meta.
  */
 export default async ({
   event: {
@@ -11,28 +12,30 @@ export default async ({
   },
   context: { space },
 }: any) => {
-  const {
-    data: {
-      objects: [message],
-    },
-  } = await request.json();
+  const { data, trigger } = (await request.json()) as RequestPayload;
 
-  const mailbox = await space.crud.query({ __typename: 'dxos.org/type/MailboxType' }).first();
-  if (!mailbox) {
-    return new Response('Mailbox not found.', { status: 500 });
-  }
+  const documentId = trigger.meta.targetDocumentId;
+  const document = await space.db.query({ id: documentId }, { format: 'plain' }).first();
 
-  await space.crud.push(
-    { id: mailbox.id },
-    {
-      sender: { email: message.from },
-      timestamp: new Date(message.created).toISOString(),
-      text: message.body,
-      properties: {
-        subject: message.subject,
-        to: [{ email: message.to }],
-      },
-    },
-  );
-  return new Response(JSON.stringify(message));
+  const contentId = document.content['/'].split(':')[3];
+  const documentContent = await space.db.query({ id: contentId }, { format: 'plain' }).first();
+  const modifiedContent = [
+    documentContent.content,
+    '',
+    '---',
+    `**From:** ${data.from}`,
+    `**Subject:** ${data.subject}`,
+    `**Date:** ${data.created}`,
+    '',
+    data.body,
+  ].join('\n');
+
+  await space.db.update({ id: contentId }, { content: modifiedContent });
+
+  return new Response(JSON.stringify({ success: true }));
+};
+
+type RequestPayload = {
+  data: { from: string; subject: string; created: string; body: string };
+  trigger: { meta: { targetDocumentId: string } };
 };

package/src/templates/forex-effect.ts

@@ -0,0 +1,41 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+// @ts-ignore
+import { defineFunction, S } from 'dxos:functions';
+import {
+  HttpClient,
+  HttpClientRequest,
+  FetchHttpClient,
+  // @ts-ignore
+} from 'https://esm.sh/@effect/platform@0.77.2?deps=effect@3.13.3';
+// @ts-ignore
+import { Effect, Schedule } from 'https://esm.sh/effect@3.13.3';
+
+export default defineFunction({
+  description: 'Returns the exchange rate between two currencies.',
+
+  inputSchema: S.Struct({
+    from: S.String.annotations({ description: 'The source currency' }),
+    to: S.String.annotations({ description: 'The target currency' }),
+  }),
+
+  outputSchema: S.String.annotations({ description: 'The exchange rate between the two currencies' }),
+
+  handler: async ({
+    event: {
+      data: { from, to },
+    },
+  }: any) =>
+    Effect.gen(function* () {
+      const res = yield* HttpClientRequest.get(`https://free.ratesdb.com/v1/rates?from=${from}&to=${to}`).pipe(
+        HttpClient.execute,
+        Effect.flatMap((res: any) => res.json),
+        Effect.timeout('1 second'),
+        Effect.retry(Schedule.exponential(1000).pipe(Schedule.compose(Schedule.recurs(3)))),
+        Effect.scoped,
+      );
+      return res.data.rates[to].toString();
+    }).pipe(Effect.provide(FetchHttpClient.layer)),
+});

package/src/templates/forex.ts

@@ -1,21 +1,28 @@
 //
-// Copyright 2024 DXOS.org
+// Copyright 2025 DXOS.org
 //
 
-/**
- * Returns the exchange rate between two currencies.
- */
-export default async ({
-  event: {
-    data: { request },
-  },
-}: any) => {
-  const { args: [from = 'EUR', to = 'USD'] = [] } = await request.json();
+// @ts-ignore
+import { defineFunction, S } from 'dxos:functions';
+
+export default defineFunction({
+  description: 'Returns the exchange rate between two currencies.',
 
-  const res = await fetch(`https://free.ratesdb.com/v1/rates?from=${from}&to=${to}`);
-  const {
-    data: { rates },
-  } = await res.json();
+  inputSchema: S.Struct({
+    from: S.String.annotations({ description: 'The source currency' }),
+    to: S.String.annotations({ description: 'The target currency' }),
+  }),
 
-  return new Response(rates[to].toString());
-};
+  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 rates[to].toString();
+  },
+});

package/src/{templates.ts → templates/index.ts}

@@ -3,15 +3,19 @@
 //
 
 // @ts-ignore
-import chat from './templates/chat.ts?raw';
+import chat from './chat.ts?raw';
 // @ts-ignore
-import chess from './templates/chess.ts?raw';
+import chess from './chess.ts?raw';
 // @ts-ignore
-import echo from './templates/echo.ts?raw';
+import discord from './discord.ts?raw';
 // @ts-ignore
-import email from './templates/email.ts?raw';
+import echo from './echo.ts?raw';
 // @ts-ignore
-import forex from './templates/forex.ts?raw';
+import email from './email.ts?raw';
+// @ts-ignore
+import forexEffect from './forex-effect.ts?raw';
+// @ts-ignore
+import forex from './forex.ts?raw';
 
 const removeHeader = (str: string) => str.split('\n').slice(4).join('\n');
 
@@ -33,6 +37,11 @@ export const templates: Template[] = [
     name: 'Forex',
     source: removeHeader(forex),
   },
+  {
+    id: 'dxos.org/script/forex-effect',
+    name: 'Forex (Effect)',
+    source: removeHeader(forexEffect),
+  },
   {
     id: 'dxos.org/script/gpt',
     name: 'Gpt',
@@ -51,4 +60,10 @@ export const templates: Template[] = [
     source: removeHeader(email),
     presetId: 'dxos.org/function/email',
   },
+  {
+    id: 'dxos.org/script/discord',
+    name: 'Discord',
+    source: removeHeader(discord),
+    presetId: 'dxos.org/function/discord',
+  },
 ];

package/src/translations.ts

@@ -2,16 +2,23 @@
 // Copyright 2023 DXOS.org
 //
 
+import { ScriptType } from '@dxos/functions';
+
 import { SCRIPT_PLUGIN } from './meta';
 
 export default [
   {
     'en-US': {
+      [ScriptType.typename]: {
+        'typename label': 'Script',
+      },
       [SCRIPT_PLUGIN]: {
         'plugin name': 'Scripts',
         'object title placeholder': 'New script',
         'create object label': 'Create script',
         'create stack section label': 'Create script',
+        'description label': 'Description',
+        'description placeholder': 'Describe what the script does.',
         'binding placeholder': 'Function name',
         'function request placeholder': 'Function request',
         'deploy label': 'Deploy',
@@ -27,6 +34,22 @@ export default [
         'function url label': 'Invocation URL',
         'function binding label': 'Function binding',
         'function binding placeholder': 'BINDING',
+        'script publish settings label': 'Publishing',
+        'script publish settings description': 'Scripts can be shared publicly as Github gists.',
+        'no github token label': 'This space has no Github access token available.',
+        'open token manager label': 'Open Token Manager',
+        'publish label': 'Publish',
+        'publishing label': 'Publishing',
+        'editor input mode label': 'Editor input mode',
+        'select editor input mode placeholder': 'Select editor input mode…',
+        'settings editor input mode default label': 'Default',
+        'settings editor input mode vim label': 'Vim',
+        'settings editor input mode vscode label': 'VS Code',
+        'view group label': 'View',
+        'view editor label': 'Editor',
+        'view split label': 'Split',
+        'view debug label': 'Debug',
+        'template select group label': 'Select template',
       },
     },
   },

package/src/types.ts

@@ -2,37 +2,38 @@
 // Copyright 2023 DXOS.org
 //
 
-import type {
-  IntentResolverProvides,
-  MetadataRecordsProvides,
-  SettingsProvides,
-  SurfaceProvides,
-  TranslationsProvides,
-} from '@dxos/app-framework';
+import { TitleAnnotationId } from '@effect/schema/AST';
+
+import { SpaceSchema } from '@dxos/client/echo';
 import { S } from '@dxos/echo-schema';
 import { ScriptType } from '@dxos/functions';
-import { type SchemaProvides } from '@dxos/plugin-space';
+import { EditorInputMode } from '@dxos/react-ui-editor';
 
 import { SCRIPT_PLUGIN } from './meta';
 
 export namespace ScriptAction {
   const SCRIPT_ACTION = `${SCRIPT_PLUGIN}/action`;
 
+  export const CreateScriptSchema = S.Struct({
+    name: S.optional(S.String),
+    // TODO(wittjosiah): Placeholder annotation?
+    gistUrl: S.optional(S.String.annotations({ [TitleAnnotationId]: 'Import from Gist (url)' })),
+  });
+
+  export type CreateScriptProps = S.Schema.Type<typeof CreateScriptSchema>;
+
   export class Create extends S.TaggedClass<Create>()(`${SCRIPT_ACTION}/create`, {
-    input: S.Struct({
-      name: S.optional(S.String),
-    }),
+    input: S.extend(CreateScriptSchema, S.Struct({ space: SpaceSchema })),
     output: S.Struct({
       object: ScriptType,
     }),
   }) {}
 }
 
-export type ScriptSettingsProps = {};
+export const ScriptSettingsSchema = S.mutable(
+  S.Struct({
+    editorInputMode: EditorInputMode,
+  }),
+);
 
-export type ScriptPluginProvides = IntentResolverProvides &
-  MetadataRecordsProvides &
-  SchemaProvides &
-  SettingsProvides<ScriptSettingsProps> &
-  SurfaceProvides &
-  TranslationsProvides;
+export type ScriptSettingsProps = S.Schema.Type<typeof ScriptSettingsSchema>;