@dxos/plugin-script 0.6.8-main.046e6cf

package/src/edge/functions.ts

@@ -0,0 +1,128 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import { type DID } from 'iso-did/types';
+
+import { Trigger } from '@dxos/async';
+import { type Config } from '@dxos/client';
+import { type Halo } from '@dxos/client-protocol';
+import { type ObjectMeta } from '@dxos/echo-schema';
+import { invariant } from '@dxos/invariant';
+import { log } from '@dxos/log';
+import { type Credential } from '@dxos/protocols/proto/dxos/halo/credentials';
+
+import { codec } from './codec';
+import { matchServiceCredential } from './hub-protocol';
+
+// TODO: use URL scheme for source?
+const USERFUNCTIONS_META_KEY = 'dxos.org/service/function';
+const USERFUNCTIONS_CREDENTIAL_CAPABILITY = 'composer:beta';
+
+// TODO: Synchronize API types with server
+export type UserFunctionUploadResult = {
+  result: 'success' | 'error';
+  errorMessage?: string;
+  functionId?: string;
+  functionVersionNumber?: number;
+};
+
+export type UploadWorkerProps = {
+  clientConfig: Config;
+  halo: Halo;
+  name?: string;
+  source: string;
+  functionId?: string;
+  ownerDid: DID;
+  credentialLoadTimeout?: number; // ms to wait for credentials to load
+};
+
+const defaultUserFunctionsBaseUrl = 'http://localhost:8600';
+// const userFunctionsBaseUrl = 'https://functions-nftest.dxos.workers.dev';
+
+const getBaseUrl = (config: Config) => {
+  return config.get('runtime.app.env.DX_USERFUNCTIONS_BASE_URL') || defaultUserFunctionsBaseUrl;
+};
+
+export const uploadWorkerFunction = async ({
+  clientConfig,
+  halo,
+  name,
+  source,
+  ownerDid,
+  functionId,
+  credentialLoadTimeout,
+}: UploadWorkerProps) => {
+  const identity = halo.identity.get();
+  if (!identity) {
+    throw new Error('Identity not available');
+  }
+  const userFunctionsBaseUrl = getBaseUrl(clientConfig);
+
+  // TODO: codify naming convention
+  const uploadUrl = `${userFunctionsBaseUrl}/${ownerDid}` + (functionId ? `/${functionId}` : '');
+
+  log('Upload', { functionId, source, name, identityKey: identity.identityKey, uploadUrl: uploadUrl.toString() });
+  const response = await fetch(uploadUrl, {
+    method: 'PUT',
+    body: JSON.stringify({ script: source, name }),
+    headers: await presentationForIdentity({ halo, timeout: credentialLoadTimeout }),
+  });
+  if (!response.ok) {
+    return (await response.json()) as UserFunctionUploadResult;
+  }
+
+  const res = await response.json();
+  log('Upload response', { status: response.status, res });
+
+  return res as UserFunctionUploadResult;
+};
+
+export const getUserFunctionUrlInMetadata = (meta: ObjectMeta) => {
+  return meta.keys.find((key) => key.source === USERFUNCTIONS_META_KEY)?.id;
+};
+
+export const setUserFunctionUrlInMetadata = (meta: ObjectMeta, functionUrl: string) => {
+  const key = meta.keys.find((key) => key.source === USERFUNCTIONS_META_KEY);
+  if (key) {
+    if (key.id !== functionUrl) {
+      throw new Error('Metadata mismatch');
+    }
+  } else {
+    meta.keys.push({ source: USERFUNCTIONS_META_KEY, id: functionUrl });
+  }
+};
+
+// TODO: handle team owner
+
+const presentationForIdentity = async ({ halo, timeout }: { halo: Halo; timeout?: number }) => {
+  let credential: Credential | undefined;
+
+  if (timeout) {
+    const credentialsLoaded = new Trigger();
+    halo.credentials.subscribe((c) => {
+      credential = c.find(matchServiceCredential([USERFUNCTIONS_CREDENTIAL_CAPABILITY]));
+      if (credential) {
+        credentialsLoaded.wake();
+      }
+    });
+    await credentialsLoaded.wait({
+      timeout,
+    });
+  } else {
+    credential = halo
+      .queryCredentials()
+      .toSorted((a, b) => b.issuanceDate.getTime() - a.issuanceDate.getTime())
+      .find(matchServiceCredential([USERFUNCTIONS_CREDENTIAL_CAPABILITY]));
+  }
+
+  if (!credential) {
+    throw new Error('No credential found');
+  }
+  log('credential found', { credential });
+  // TODO(wittjosiah): If id is required to present credentials, then it should always be present for queried credentials.
+  invariant(credential.id, 'beta credential missing id');
+  const presentation = await halo.presentCredentials({ ids: [credential.id] });
+
+  return { Authorization: `Bearer ${codec.encode(presentation)}` };
+};

package/src/edge/header-codec.ts

@@ -0,0 +1,97 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+// TODO(burdon): Factor out from @dxos/hub-protocol
+
+const ENCODING = 'base64';
+
+export type EncodedKey = { __k: string };
+
+export type EncodedBytes = { __b: string };
+
+export type EncodedTimestamp = { __t: number };
+
+export interface KeyCodec<KeyType> {
+  isKey(value: any): value is KeyType;
+  encode(key: KeyType): EncodedKey;
+  decode(value: EncodedKey): KeyType;
+}
+
+// TODO(wittjosiah): Use deepMapValues from @dxos/util -- it handles recursion for you.
+export class HeaderCodec<Key> {
+  constructor(private readonly _keyCodec: KeyCodec<Key>) {}
+
+  encode(obj: any): string {
+    const objectToEncode = this._prepareForEncoding(obj);
+    const encoded = Buffer.from(JSON.stringify(objectToEncode));
+    return encoded.toString(ENCODING);
+  }
+
+  decode<Type>(buffer: string): Type {
+    const json = JSON.parse(Buffer.from(buffer, ENCODING).toString());
+    return this._decodeRecursive(json);
+  }
+
+  private _decodeRecursive(obj: any): any {
+    return this._recurse(obj, (value) => {
+      if (isEncodedBytes(value)) {
+        return decodeBytes(value.__b);
+      }
+      if (isEncodedKey(value)) {
+        return this._keyCodec.decode(value);
+      }
+      if (isEncodedDate(value)) {
+        return decodeDate(value);
+      }
+      return null;
+    });
+  }
+
+  private _prepareForEncoding(obj: any): any {
+    return this._recurse(obj, (value) => {
+      if (value instanceof Uint8Array) {
+        return { __b: encodeBytes(value) };
+      }
+      if (this._keyCodec.isKey(value)) {
+        return this._keyCodec.encode(value);
+      }
+      if (value instanceof Date) {
+        return encodeDate(value);
+      }
+      return null;
+    });
+  }
+
+  private _recurse(obj: any, handler: (obj: object) => any | null): any {
+    if (typeof obj !== 'object') {
+      return obj;
+    }
+    const handled = handler(obj);
+    if (handled != null) {
+      return handled;
+    }
+    if (Array.isArray(obj)) {
+      const result = [];
+      for (const elem of obj) {
+        result.push(this._recurse(elem, handler));
+      }
+      return result;
+    }
+    const result: any = {};
+    for (const [key, value] of Object.entries(obj)) {
+      result[key] = this._recurse(value, handler);
+    }
+    return result;
+  }
+}
+
+const isEncodedKey = (obj: object): obj is EncodedKey => '__k' in obj && typeof obj.__k === 'string';
+const isEncodedBytes = (obj: object): obj is EncodedBytes => '__b' in obj && typeof obj.__b === 'string';
+const isEncodedDate = (obj: object): obj is EncodedTimestamp => '__t' in obj && typeof obj.__t === 'number';
+
+const encodeDate = (date: Date) => ({ __t: date.getTime() });
+const decodeDate = (timestamp: EncodedTimestamp) => new Date(timestamp.__t);
+
+const encodeBytes = (bytes: Uint8Array) => Buffer.from(bytes).toString(ENCODING);
+const decodeBytes = (bytes: string) => Buffer.from(bytes, ENCODING);

package/src/edge/hub-protocol.ts

@@ -0,0 +1,27 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import { type DID } from 'iso-did/types';
+
+import { type Credential } from '@dxos/client/halo';
+import { type PublicKey } from '@dxos/keys';
+
+// TODO(burdon): Factor out to @dxos/hub-protocol.
+
+export const matchServiceCredential =
+  (capabilities: string[] = []) =>
+  (credential: Credential) => {
+    if (credential.subject.assertion['@type'] !== 'dxos.halo.credentials.ServiceAccess') {
+      return false;
+    }
+
+    const { capabilities: credentialCapabilities } = credential.subject.assertion;
+    return capabilities.every((capability) => credentialCapabilities.includes(capability));
+  };
+
+// TODO: reconcile with @dxos/hub-protocol
+
+export const publicKeyToDid = (key: PublicKey): DID => {
+  return `did:key:${key.toHex()}`;
+};

package/src/edge/index.ts

@@ -0,0 +1,10 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+// TODO(wittjosiah): Factor out.
+
+export * from './codec';
+export * from './functions';
+export * from './header-codec';
+export * from './hub-protocol';

package/src/index.ts

@@ -0,0 +1,13 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import { ScriptPlugin } from './ScriptPlugin';
+
+export default ScriptPlugin;
+
+export * from './compiler';
+export * from './components';
+export * from './types';
+
+export * from './ScriptPlugin';

package/src/meta.tsx

@@ -0,0 +1,19 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import { Code, type IconProps } from '@phosphor-icons/react';
+import React from 'react';
+
+import { pluginMeta } from '@dxos/app-framework';
+
+export const SCRIPT_PLUGIN = 'dxos.org/plugin/script';
+
+export default pluginMeta({
+  id: SCRIPT_PLUGIN,
+  name: 'Scripts',
+  description: 'Live code notebooks.',
+  tags: ['experimental'],
+  iconComponent: (props: IconProps) => <Code {...props} />,
+  iconSymbol: 'ph--code--regular',
+});

package/src/translations.ts

@@ -0,0 +1,25 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import { SCRIPT_PLUGIN } from './meta';
+
+export default [
+  {
+    'en-US': {
+      [SCRIPT_PLUGIN]: {
+        'plugin name': 'Scripts',
+        'object title placeholder': 'New script',
+        'create object label': 'Create script',
+        'create stack section label': 'Create script',
+        'binding label': 'Binding',
+        'binding placeholder': 'Enter binding',
+        'edit binding label': 'Edit binding',
+        'deploy label': 'Deploy',
+        'deployed label': 'Current version of the script is deployed',
+        'upload failed label': 'Upload failed',
+        'copy link label': 'Copy function link',
+      },
+    },
+  },
+];

package/src/types/index.ts

@@ -0,0 +1,6 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+export * from './script';
+export * from './types';

package/src/types/script.ts

@@ -0,0 +1,16 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import { ref, S, TypedObject } from '@dxos/echo-schema';
+import { TextType } from '@dxos/plugin-markdown/types';
+
+export class ScriptType extends TypedObject({ typename: 'dxos.org/type/Script', version: '0.1.0' })({
+  name: S.optional(S.String),
+  source: ref(TextType),
+
+  // Local binding to a function name.
+  binding: S.optional(S.String),
+  // Whether source has changed since last deploy.
+  changed: S.optional(S.Boolean),
+}) {}

package/src/types/types.tsx

@@ -0,0 +1,27 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import type {
+  GraphBuilderProvides,
+  IntentResolverProvides,
+  MetadataRecordsProvides,
+  SurfaceProvides,
+  TranslationsProvides,
+} from '@dxos/app-framework';
+import { type SchemaProvides } from '@dxos/plugin-client';
+import type { StackProvides } from '@dxos/plugin-stack';
+
+import { SCRIPT_PLUGIN } from '../meta';
+
+export enum ScriptAction {
+  CREATE = `${SCRIPT_PLUGIN}/create`,
+}
+
+export type ScriptPluginProvides = SurfaceProvides &
+  IntentResolverProvides &
+  GraphBuilderProvides &
+  MetadataRecordsProvides &
+  TranslationsProvides &
+  SchemaProvides &
+  StackProvides;