@fleek-platform/agents-ui

⚡️Fleek Platform Agents UI

The Agents UI provides standalone functionality for the Eliza Agents. Originally it is implemented in the fleek-platform/website repository but the team took a decision to extract it into a separate, standalone package for maintainability purposes, separating concerns and easier management of requirements.

There was a transition period when code lived in both repositories and had to be encapsulated and synced to prevent diversion and maintenance overhead.

Overview

• 🤖 Install
• 👷‍♀️Development
  • Environment Variables
  • Changeset
  • Local Package Test
  • Stripe Testing
• 🧸 Basic Usage
  • Interface
  • Example usage
• 🚀 Package Release
• 🙏 Contributing
  • Branching strategy
  • Contributing
• ⏱️ Changelog

Install

Install the package by executing:

npm i @fleek-platform/agents-ui

⚠️ If you're planning to contribute as a developer, you must install pnpm, otherwise most commands will fail.

For a quick start, learn the basic usage.

Development

For developers looking to contribute to the @fleek-platform/agents-ui, clone the repository and follow the contribution guide.

For runtime we utilize Nodejs and PNPM as the package manager.

Next, install the project dependencies:

pnpm i

Environment variables

If you'll be interacting with services, you'll need to set up the environment variables.

Create a local file named .env and declare the following environment variables for the environment you're interested (below we're using the public~production settings):

PUBLIC_FLEEK_REST_API_URL="https://api.fleek.xyz"
PUBLIC_UI_APP_URL="https://app.fleek.xyz"
PUBLIC_BEEHIIV_PROXY_SERVER_URL="https://faas-lon1-917a94a7.doserverless.co/api/v1/web/fn-5aaf2a72-1b5b-4ac6-8c42-a2e735a32d8b/main/create-subscription"

The application uses the getDefined to lookup for environment variables.

Stripe Tests

Tests can be performed in the staging environment due to a sandbox version of stripe.

Here's a quick example of a credit-card number:

5200 8282 8282 8210

To learn more visit the documentation here.

Changeset

Manage the versioning of changelog entries.

Declare an intent to release by executing the command and answering the wizard's questions:

pnpm changeset:add

Local Package Test

Since npm link is a command-line tool for symlinking a local package as a dependency during development. It is commonly used for testing packages before publishing them. But it's common to cause confusion and unexpected behaviour.

Instead of using pnpm link for local package testing, use the following command, that's closer to release install.

pnpm generate:local_package

Once successful, the console will display an install command that you can copy and run in your project.

Here's an example that uses npm:

npm i --no-save <GENERATED_FILE_PATH>

[!WARNING]
Remove concurrent package name from package.json, e.g. @fleek-platform/agents-ui. The local install doesn't save or modify the package.json. The package.json and lockfiles are only for existing registry versions. You might have to run the clean command to remove any conflicting packages from node_modules, locks, etc.

Alternatively, if you're using an npm-compatible package manager like pnpm, avoid saving or modifying the lock file, e.g:

npm_config_save=false npm_config_lockfile=false pnpm i <GENERATED_FILE_PATH>

Basic usage

Package is distributed as ESM module that exports source code, transpiling and processing is left to the host application. To use it, you need to do the following:

1. Make sure that it is included as a dependency.

// package.json

"dependencies": {
  "@fleek-platform/agents-ui": "*", // specify the correct version
  // ...
}

1. Import ElizaIntegrationLayer component and pass the required props.

Interface

Package defines the expected interface inside the ElizaIntegrationLayer.tsx component. The host app is expected to pass the following props:

// package
// src/components/Eliza/ElizaIntegrationLayer.tsx

export interface ElizaIntegrationLayerProps {
  // auth props
  isLoggedIn: boolean;
  isLoggingIn: boolean;
  login: () => Promise<void>;
  fetchFleekToken: (projectId?: string) => Promise<string | undefined>;
  getSubscriptions: getSubscriptionsType;
  getPlans: getPlansType;
  // active project props
  activeProjectId: string;
}

// callback types, please see the source for the exact response shape 
type getSubscriptionsType = (projectId?: string,  token?: string) => Promise<{ ... }>;
type getPlansType = (token?: string) => Promise<{ ... }>;

Not all data is passed via props, additional data is passed via the src/settings.json common configuration file. Components inside the src/components/Eliza import this file. These are the required fields by the package (host app may define other, additional fields):

// src/settings.json

{
  "elizaPage": {
    "endpoints": {
      "aiAgents": "ai-agents endpoint url"
    },
    "agentsDashboardPage": "dashboard url"
  }
}

💡 Note: You must use relative import for this file.

import settings from '../../../settings.json'; // ✅ will work

import settings from '@base/settings.json'; // ❌ will fail

Example usage

Example usage inside the host app, e.g. fleek-platform/website:

// src/components/AgentsUI/index.tsx

// import styles
import '@fleek-platform/agents-ui/styles';

// import implementation from the package
import { ElizaIntegrationLayer, api } from '@fleek-platform/agents-ui';

const {
  createSubscription,
  getPlans,
  getSubscriptions,
} = api;

export const AgentsUIIntegration: React.FC = () => {
  const { triggerLoginModal, accessToken, isLoggingIn, isLoggedIn, projectId } =
    useAuthStore();
  const login = () =>
    typeof triggerLoginModal === 'function' && triggerLoginModal(true);

  return (
    <ElizaIntegrationLayer
      accessToken={accessToken}
      activeProjectId={projectId}
      isLoggedIn={isLoggedIn}
      isLoggingIn={isLoggingIn}
      login={login}
      getSubscriptions={getSubscriptions}
      getPlans={getPlans}
      createSubscription={createSubscription}
    />
  );
};

const AgentsUI: React.FC = () => <AgentsUIIntegration />;

// to be used in Astro
export default AgentsUI;

Package Release

When a branch is merged into main or develop, the npm-publisher.yml workflow is triggered to publish packages to the appropriate registry.

For the main branch, packages are published to the npmjs.org registry, ensuring they are available for public use.

Conversely, when changes are merged into the develop branch, packages are published to the GitHub Registry packages (GHCR) , which serves as a staging environment.

This setup allows for a clear separation between production-ready packages and those in development.

Contributing

This section guides you through the process of contributing to our open-source project. From creating a feature branch to submitting a pull request, get started by:

1. Fork the project here
2. Create your feature branch using our branching strategy, e.g. git checkout -b feat/my-new-feature
3. Run the tests: pnpm test
4. Commit your changes by following our commit conventions, e.g. git commit -m 'chore: 🤖 my contribution description'
5. Push to the branch, e.g. git push origin feat/my-new-feature
6. Create new Pull Request following the corresponding template guidelines

Branching strategy

The develop branch serves as the main integration branch for features, enhancements, and fixes. It is always in a deployable state and represents the latest development version of the application.

Feature branches are created from the develop branch and are used to develop new features or enhancements. They should be named according to the type of work being done and the scope of the feature and in accordance with conventional commits here.

Conventional commits

We prefer to commit our work following Conventional Commits conventions. Conventional Commits are a simple way to write commit messages that both people and computers can understand. It help us keep track fo changes in a consistent manner, making it easier to see what was added, changed, or fixed in each commit or update.

The commit messages are formatted as [type]/[scope] The type is a short descriptor indicating the nature of the work (e.g., feat, fix, docs, style, refactor, test, chore). This follows the conventional commit types.

The scope is a more detailed description of the feature or fix. This could be the component or part of the codebase affected by the change.

Here's an example of different conventional commits messages that you should follow:

test: 💍 Adding missing tests
feat: 🎸 A new feature
fix: 🐛 A bug fix
chore: 🤖 Build process or auxiliary tool changes
docs: 📝 Documentation only changes
refactor: 💡 A code change that neither fixes a bug or adds a feature
style: 💄 Markup, white-space, formatting, missing semi-colons...