@minded-ai/mindedjs 1.0.0-ec2-beta-1

package/src/platform/piiGateway/gateway.ts

@@ -0,0 +1,103 @@
+import { v4 as uuidv4 } from 'uuid';
+import * as mindedConnection from '../mindedConnection';
+import { mindedConnectionSocketMessageType, OnPiiHttpRequest, OnPiiHttpResponse } from '../mindedConnectionTypes';
+import { HttpRequestConfig, HttpResponse, PIIGatewayInstance } from './types';
+import { logger } from '../../utils/logger';
+
+export class PIIGateway implements PIIGatewayInstance {
+  constructor() {
+    // No longer needs mindedConnection as parameter
+  }
+
+  private async makeRequest<T = any>(
+    sessionId: string,
+    method: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS',
+    url: string,
+    data?: any,
+    config?: HttpRequestConfig,
+  ): Promise<HttpResponse<T>> {
+    if (!mindedConnection.isConnected()) {
+      throw new Error('Minded connection is not established. PII-secured HTTP requests require a connection to the Minded platform.');
+    }
+
+    try {
+      const requestId = uuidv4();
+      const requestPayload: OnPiiHttpRequest = {
+        type: mindedConnectionSocketMessageType.PII_HTTP_REQUEST,
+        requestId,
+        method,
+        url,
+        headers: config?.headers as Record<string, string>,
+        params: config?.params,
+        data,
+        sessionId,
+      };
+
+      const response = await mindedConnection.awaitEmit<OnPiiHttpRequest, OnPiiHttpResponse>(
+        mindedConnectionSocketMessageType.PII_HTTP_REQUEST,
+        requestPayload,
+        30000, // 30 second timeout for HTTP requests
+      );
+
+      if (response.error) {
+        throw new Error(`HTTP request failed: ${response.error}`);
+      }
+
+      // Verify that the response requestId matches our request
+      if (response.requestId && response.requestId !== requestId) {
+        logger.warn(`Response requestId (${response.requestId}) does not match request requestId (${requestId})`);
+      }
+
+      // Return generic HttpResponse format
+      return {
+        data: response.data,
+        status: response.status || 200,
+        statusText: response.statusText || 'OK',
+        headers: response.headers || {},
+        config: config || {},
+      };
+    } catch (err) {
+      logger.error({ message: 'Secure HTTP request failed', err });
+      return {
+        data: undefined as T,
+        status: 500,
+        statusText: 'Internal Server Error',
+        headers: {},
+        config: config || {},
+      };
+    }
+  }
+
+  async get<T = any>(sessionId: string, url: string, config?: HttpRequestConfig): Promise<HttpResponse<T>> {
+    return this.makeRequest<T>(sessionId, 'GET', url, undefined, config);
+  }
+
+  async post<T = any>(sessionId: string, url: string, data?: any, config?: HttpRequestConfig): Promise<HttpResponse<T>> {
+    return this.makeRequest<T>(sessionId, 'POST', url, data, config);
+  }
+
+  async put<T = any>(sessionId: string, url: string, data?: any, config?: HttpRequestConfig): Promise<HttpResponse<T>> {
+    return this.makeRequest<T>(sessionId, 'PUT', url, data, config);
+  }
+
+  async delete<T = any>(sessionId: string, url: string, config?: HttpRequestConfig): Promise<HttpResponse<T>> {
+    return this.makeRequest<T>(sessionId, 'DELETE', url, undefined, config);
+  }
+
+  async patch<T = any>(sessionId: string, url: string, data?: any, config?: HttpRequestConfig): Promise<HttpResponse<T>> {
+    return this.makeRequest<T>(sessionId, 'PATCH', url, data, config);
+  }
+
+  async head<T = any>(sessionId: string, url: string, config?: HttpRequestConfig): Promise<HttpResponse<T>> {
+    return this.makeRequest<T>(sessionId, 'HEAD', url, undefined, config);
+  }
+
+  async options<T = any>(sessionId: string, url: string, config?: HttpRequestConfig): Promise<HttpResponse<T>> {
+    return this.makeRequest<T>(sessionId, 'OPTIONS', url, undefined, config);
+  }
+
+  async request<T = any>(sessionId: string, config: HttpRequestConfig): Promise<HttpResponse<T>> {
+    const method = (config.method?.toUpperCase() || 'GET') as any;
+    return this.makeRequest<T>(sessionId, method, config.url || '', config.data, config);
+  }
+}

package/src/platform/piiGateway/index.ts

@@ -0,0 +1,5 @@
+// Export types
+export type { HttpRequestConfig, HttpResponse, PIIGatewayInstance } from './types';
+
+// Export core gateway class and creation function
+export { PIIGateway } from './gateway';

package/src/platform/piiGateway/types.ts

@@ -0,0 +1,29 @@
+// Generic HTTP types (library-agnostic)
+export interface HttpRequestConfig {
+  method?: string;
+  url?: string;
+  headers?: Record<string, string>;
+  params?: Record<string, any>;
+  data?: any;
+  timeout?: number;
+  [key: string]: any; // Allow additional properties for extensibility
+}
+
+export interface HttpResponse<T = any> {
+  data: T;
+  status: number;
+  statusText: string;
+  headers: Record<string, string>;
+  config: HttpRequestConfig;
+}
+
+export interface PIIGatewayInstance {
+  get<T = any>(sessionId: string, url: string, config?: HttpRequestConfig): Promise<HttpResponse<T>>;
+  post<T = any>(sessionId: string, url: string, data?: any, config?: HttpRequestConfig): Promise<HttpResponse<T>>;
+  put<T = any>(sessionId: string, url: string, data?: any, config?: HttpRequestConfig): Promise<HttpResponse<T>>;
+  delete<T = any>(sessionId: string, url: string, config?: HttpRequestConfig): Promise<HttpResponse<T>>;
+  patch<T = any>(sessionId: string, url: string, data?: any, config?: HttpRequestConfig): Promise<HttpResponse<T>>;
+  head<T = any>(sessionId: string, url: string, config?: HttpRequestConfig): Promise<HttpResponse<T>>;
+  options<T = any>(sessionId: string, url: string, config?: HttpRequestConfig): Promise<HttpResponse<T>>;
+  request<T = any>(sessionId: string, config: HttpRequestConfig): Promise<HttpResponse<T>>;
+}

package/src/platform/toolExecutor.ts

@@ -0,0 +1,106 @@
+import { Tool } from '../types/Tools.types';
+import { Agent } from '../agent';
+import { logger } from '../utils/logger';
+
+export interface ToolExecutionRequest {
+  toolName: string;
+  toolParams: any;
+  sessionId: string;
+  requestId: string;
+  cdpUrl?: string;
+}
+
+export interface ToolExecutionResponse {
+  result?: any;
+  state?: any;
+  error?: string;
+}
+
+export class ToolExecutor {
+  private tools: Map<string, Tool<any, any>> = new Map();
+
+  constructor(private agent: Agent) {}
+
+  /**
+   * Register tools for standalone execution
+   */
+  registerTools(tools: Tool<any, any>[]) {
+    tools.forEach((tool) => {
+      if (tool.allowExecutionRequests === true) {
+        this.tools.set(tool.name, tool);
+      }
+    });
+  }
+
+  /**
+   * Execute a tool by name with given parameters
+   * This is called when browser-use requests tool execution via socket
+   */
+  async executeTool(request: ToolExecutionRequest): Promise<ToolExecutionResponse> {
+    const { toolName, toolParams, sessionId, cdpUrl } = request;
+
+    try {
+      // Find the tool
+      const tool = this.tools.get(toolName);
+      if (!tool) {
+        throw new Error(`Tool not found: ${toolName}`);
+      }
+
+      // We only allow to execute tools that are marked as allowed to be executed
+
+      logger.debug({
+        msg: '[ToolExecutor] Executing tool',
+        toolName,
+        sessionId,
+        hasCdpUrl: !!cdpUrl,
+      });
+
+      // Get the current state for the session
+      const state = await this.agent.getState(sessionId);
+      if (!state) {
+        throw new Error(`Session state not found: ${sessionId}`);
+      }
+
+      // Execute the tool
+      const startTime = Date.now();
+
+      if (cdpUrl) {
+        state.cdp = {
+          url: cdpUrl,
+          sessionId: state.cdp?.sessionId || null,
+          liveUrl: state.cdp?.liveUrl || null,
+        };
+      }
+
+      await tool.execute({
+        input: toolParams,
+        state,
+        agent: this.agent,
+      });
+      const endTime = Date.now();
+
+      logger.debug({
+        msg: '[ToolExecutor] Tool execution completed',
+        toolName,
+        executionTimeMs: endTime - startTime,
+      });
+
+      // Always update the session state after tool execution req
+      await this.agent.updateState({ sessionId, state });
+
+      return {
+        state,
+      };
+    } catch (err) {
+      logger.error({
+        message: '[ToolExecutor] Error executing tool',
+        toolName,
+        err,
+      });
+
+      return {
+        error: err instanceof Error ? err.message : String(err),
+      };
+    }
+  }
+}

package/src/platform/utils/parseAttachments.ts

@@ -0,0 +1,56 @@
+/**
+ * Parses attachments from a trigger body and formats them as a string
+ * @param triggerBody - The trigger body containing potential attachments
+ * @returns Formatted string of attachments or empty string if no attachments
+ */
+export const parseAttachments = (triggerBody: any): string => {
+  // Check if triggerBody has attachments
+  const attachments = triggerBody?.attachments;
+
+  if (!attachments || !Array.isArray(attachments) || attachments.length === 0) {
+    return '';
+  }
+
+  // Format attachments
+  const attachmentStrings = attachments
+    .map((attachment: any) => {
+      const lines: string[] = [];
+
+      if (attachment.originalname) {
+        lines.push(`originalName: ${attachment.originalname}`);
+      } else if (attachment.name) {
+        lines.push(`originalName: ${attachment.name}`);
+      }
+
+      if (attachment.path) {
+        lines.push(`localPath: ${attachment.path}`);
+      }
+
+      return lines.join('\n');
+    })
+    .filter((str) => str.length > 0);
+
+  if (attachmentStrings.length === 0) {
+    return '';
+  }
+
+  return 'Attachments:\n' + attachmentStrings.join('\n\n');
+};
+
+/**
+ * Combines content with attachments string
+ * @param content - The main content string
+ * @param attachmentsString - The formatted attachments string
+ * @returns Combined content with attachments
+ */
+export const combineContentWithAttachments = (content: string, attachmentsString: string): string => {
+  if (!attachmentsString) {
+    return content;
+  }
+
+  if (!content) {
+    return attachmentsString;
+  }
+
+  return `${content}\n${attachmentsString}`;
+};

package/src/platform/utils/tools.ts

@@ -0,0 +1,55 @@
+import { logger } from '../../utils/logger';
+
+/**
+ * Convert Zod schema to parameter format
+ * This is a simplified version - you might need to expand based on your needs
+ */
+export const zodSchemaToParams = (zodSchema: any): any[] => {
+  try {
+    // Get the shape of the Zod object
+    const shape = zodSchema._def?.shape?.() || {};
+    const params = [];
+
+    for (const [key, value] of Object.entries(shape)) {
+      const zodValue = value as any; // Zod schema type
+      const param: any = {
+        name: key,
+        type: getZodType(zodValue),
+        required: !zodValue.isOptional?.(),
+        description: zodValue._def?.description || '',
+      };
+
+      params.push(param);
+    }
+
+    return params;
+  } catch (err) {
+    logger.warn({
+      message: '[ToolExecutor] Error parsing Zod schema',
+      err,
+    });
+    return [];
+  }
+};
+
+/**
+ * Get type string from Zod type
+ */
+const getZodType = (zodType: any): string => {
+  const typeName = zodType._def?.typeName;
+
+  switch (typeName) {
+    case 'ZodString':
+      return 'string';
+    case 'ZodNumber':
+      return 'number';
+    case 'ZodBoolean':
+      return 'boolean';
+    case 'ZodArray':
+      return 'array';
+    case 'ZodObject':
+      return 'object';
+    default:
+      return 'any';
+  }
+};

package/src/playbooks/playbooks.ts

@@ -0,0 +1,200 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as yaml from 'js-yaml';
+import * as mindedConnection from '../platform/mindedConnection';
+import { mindedConnectionSocketMessageType } from '../platform/mindedConnectionTypes';
+import { getConfig } from '../platform/config';
+import { logger } from '../utils/logger';
+import { OutputBlockData } from '@editorjs/editorjs';
+import { Environment } from '../types/Platform.types';
+
+export type Playbook = {
+  id: string;
+  name: string;
+  blocks: OutputBlockData[];
+};
+
+/**
+ * Decode HTML entities in a string
+ */
+function decodeHtmlEntities(text: string): string {
+  const entities: Record<string, string> = {
+    '&amp;': '&',
+    '&lt;': '<',
+    '&gt;': '>',
+    '&quot;': '"',
+    '&#39;': "'",
+    '&apos;': "'",
+    '&#x27;': "'",
+    '&#x2F;': '/',
+    '&#x60;': '`',
+    '&#x3D;': '=',
+  };
+
+  return text.replace(/&[#\w]+;/g, (entity) => entities[entity] || entity);
+}
+
+/**
+ * Convert EditorJS blocks to markdown
+ */
+function editorJsToMarkdown(blocks: OutputBlockData[]): string {
+  if (!blocks || blocks.length === 0) {
+    return '';
+  }
+
+  return blocks
+    .map((block) => {
+      try {
+        switch (block.type) {
+          case 'header': {
+            const level = block.data?.level || 1;
+            const headerPrefix = '#'.repeat(level);
+            const text = block.data?.text || '';
+            return `${headerPrefix} ${decodeHtmlEntities(text)}`;
+          }
+
+          case 'paragraph': {
+            const text = block.data?.text || '';
+            return decodeHtmlEntities(text);
+          }
+
+          case 'list': {
+            const items = block.data?.items || [];
+            const style = block.data?.style || 'unordered';
+            return items
+              .map((item: { content: string }, index: number) => {
+                const decodedItem = decodeHtmlEntities(item.content);
+                if (style === 'ordered') {
+                  return `${index + 1}. ${decodedItem}`;
+                } else {
+                  return `- ${decodedItem}`;
+                }
+              })
+              .join('\n');
+          }
+
+          case 'quote': {
+            const text = block.data?.text || '';
+            const caption = block.data?.caption ? `\n*${decodeHtmlEntities(block.data.caption)}*` : '';
+            return `> ${decodeHtmlEntities(text)}${caption}`;
+          }
+
+          case 'code': {
+            const code = block.data?.code || '';
+            return `\`\`\`\n${decodeHtmlEntities(code)}\n\`\`\``;
+          }
+
+          case 'delimiter': {
+            return '---';
+          }
+
+          default: {
+            logger.warn(`Unknown playbook block type: ${block.type}`);
+            return '';
+          }
+        }
+      } catch (err) {
+        logger.error({ message: 'Error converting EditorJS blocks to markdown', err, block });
+        throw err;
+      }
+    })
+    .join('\n\n');
+}
+
+/**
+ * Load playbooks from directories or platform
+ */
+export async function loadPlaybooks(playbooksDirectories?: string[]): Promise<Playbook[]> {
+  const { env, isDeployed } = getConfig();
+  let playbooks: Playbook[] = [];
+
+  if ([Environment.DEVELOPMENT].includes(env) && isDeployed && mindedConnection.isConnected()) {
+    // Load from platform
+    const response = await mindedConnection.awaitEmit<object, { playbooks?: Playbook[]; error?: string }>(
+      mindedConnectionSocketMessageType.GET_PLAYBOOKS,
+      {},
+    );
+
+    if (response?.error) {
+      throw new Error(`Failed to load playbooks from platform: ${response.error}`);
+    }
+
+    playbooks = response?.playbooks || [];
+  } else if (playbooksDirectories) {
+    // Load from directories
+    playbooks = loadPlaybooksFromDirectories(playbooksDirectories);
+  }
+
+  return playbooks;
+}
+
+/**
+ * Load playbooks from local directories
+ */
+function loadPlaybooksFromDirectories(directories: string[]): Playbook[] {
+  const playbooks: Playbook[] = [];
+
+  for (const directory of directories) {
+    if (!fs.existsSync(directory)) {
+      logger.info({ msg: `Playbooks directory does not exist: ${directory}` });
+      continue;
+    }
+
+    const files = getAllYamlFiles(directory);
+
+    for (const file of files) {
+      try {
+        const fileContent = fs.readFileSync(file, 'utf8');
+        const playbook = yaml.load(fileContent) as Playbook;
+
+        if (playbook && playbook.name && playbook.blocks) {
+          playbooks.push(playbook);
+          logger.info({ msg: `Loaded playbook: ${playbook.name} from ${file}` });
+        } else {
+          logger.warn({ msg: `Invalid playbook structure in ${file}` });
+        }
+      } catch (err) {
+        logger.error({ message: `Failed to load playbook file ${file}: ${err}` });
+      }
+    }
+  }
+
+  return playbooks;
+}
+
+/**
+ * Recursively get all YAML files in a directory
+ */
+function getAllYamlFiles(dir: string): string[] {
+  const files: string[] = [];
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...getAllYamlFiles(fullPath));
+    } else if (entry.name.endsWith('.yaml') || entry.name.endsWith('.yml')) {
+      files.push(fullPath);
+    }
+  }
+
+  return files;
+}
+
+/**
+ * Combine playbooks into a single string
+ */
+export function combinePlaybooks(playbooks: Playbook[]): string | null {
+  if (playbooks.length === 0) {
+    return null;
+  }
+
+  // Combine all playbooks into sections
+  const sections = playbooks.map((playbook) => {
+    const markdownContent = editorJsToMarkdown(playbook.blocks);
+    return `# ${playbook.name}\n${markdownContent}`;
+  });
+
+  const combinedPlaybooks = sections.join('\n\n');
+  return combinedPlaybooks;
+}