@minded-ai/mindedjs 2.0.13 → 2.0.14

package/src/cli/localOperatorSetup.ts

@@ -0,0 +1,308 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { execSync, spawn } from 'child_process';
+import * as readline from 'readline';
+
+const VENV_DIR = '.venv';
+const SETUP_MARKER_FILE = '.minded-local-operator-setup';
+
+interface SetupPackage {
+  name: string;
+  description: string;
+  command: string;
+  checkCommand?: string;
+}
+
+const REQUIRED_PACKAGES: SetupPackage[] = [
+  {
+    name: 'uv',
+    description: 'Python package manager for fast dependency installation',
+    command: 'curl -LsSf https://astral.sh/uv/install.sh | sh',
+    checkCommand: 'uv --version',
+  },
+  {
+    name: 'Python 3.12',
+    description: 'Python runtime for browser automation',
+    command: 'python3.12 --version',
+    checkCommand: 'python3.12 --version',
+  },
+  {
+    name: 'browser-use',
+    description: 'Browser automation library',
+    command: 'uv pip install browser-use',
+  },
+  {
+    name: 'Playwright Chromium',
+    description: 'Chromium browser for automation',
+    command: 'uvx playwright install chromium --with-deps',
+  },
+];
+
+export function isLocalOperatorSetup(): boolean {
+  const setupMarkerPath = path.join(process.cwd(), SETUP_MARKER_FILE);
+  const venvPath = path.join(process.cwd(), VENV_DIR);
+
+  // Check if both the marker file and venv directory exist
+  return fs.existsSync(setupMarkerPath) && fs.existsSync(venvPath);
+}
+
+function checkCommand(command: string): boolean {
+  try {
+    execSync(command, { stdio: 'ignore' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function promptUser(question: string): Promise<boolean> {
+  // Check if we're in an interactive terminal
+  if (!process.stdin.isTTY) {
+    console.warn('Non-interactive terminal detected, skipping prompt and cancelling installation');
+    return Promise.resolve(false);
+  }
+
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+    });
+
+    // Set a timeout in case the prompt hangs
+    const timeout = setTimeout(() => {
+      console.warn('Prompt timeout (30s), cancelling installation');
+      rl.close();
+      resolve(false);
+    }, 30000); // 30 second timeout
+
+    console.log('Displaying prompt to user');
+
+    rl.question(question, (answer) => {
+      clearTimeout(timeout);
+      console.log(`User answered: "${answer}"`);
+
+      rl.close();
+
+      const confirmed = answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes';
+      console.log(`Prompt result: ${confirmed}`);
+
+      resolve(confirmed);
+    });
+
+    // Handle potential readline errors
+    rl.on('error', (error) => {
+      console.error('Readline error, cancelling installation:', error.message);
+      clearTimeout(timeout);
+      rl.close();
+      resolve(false);
+    });
+  });
+}
+
+async function runCommand(command: string, description: string): Promise<void> {
+  return new Promise((resolve, reject) => {
+    console.log(`Installing ${description}...`);
+
+    const isComplexCommand = command.includes('|') || command.includes('&&');
+
+    if (isComplexCommand) {
+      // For complex commands with pipes or &&, use shell
+      const child = spawn('sh', ['-c', command], {
+        stdio: 'inherit',
+        shell: true,
+      });
+
+      child.on('error', (error) => {
+        console.error(`Failed to install ${description}:`, error.message);
+        reject(error);
+      });
+
+      child.on('close', (code) => {
+        if (code === 0) {
+          console.log(`✓ ${description} installed successfully`);
+          resolve();
+        } else {
+          reject(new Error(`Command exited with code ${code}`));
+        }
+      });
+    } else {
+      // For simple commands, use execSync
+      try {
+        execSync(command, { stdio: 'inherit' });
+        console.log(`✓ ${description} installed successfully`);
+        resolve();
+      } catch (error) {
+        console.error(`Failed to install ${description}:`, error);
+        reject(error);
+      }
+    }
+  });
+}
+
+export async function setupLocalOperator(skipPrompt: boolean = false): Promise<void> {
+  console.log('\n🤖 Minded Local Operator Setup\n');
+
+  // Check if already setup
+  if (isLocalOperatorSetup()) {
+    console.log('✓ Local operator is already set up');
+    return;
+  }
+
+  // Display what will be installed
+  console.log('The following packages will be installed for local browser automation:\n');
+  REQUIRED_PACKAGES.forEach((pkg, index) => {
+    console.log(`  ${index + 1}. ${pkg.name} - ${pkg.description}`);
+  });
+  console.log('');
+
+  // Ask for confirmation unless skipped
+  if (!skipPrompt) {
+    console.log('Waiting for user confirmation...');
+    const confirmed = await promptUser('Do you want to proceed with the installation? (y/n): ');
+    if (!confirmed) {
+      console.log('Installation cancelled by user');
+      process.exit(0);
+    }
+    console.log('User confirmed, proceeding with installation');
+  } else {
+    console.log('Skipping confirmation prompt, proceeding with installation...');
+  }
+
+  console.log('\n📦 Starting installation...\n');
+
+  try {
+    // Check and install uv if needed
+    if (!checkCommand('uv --version')) {
+      console.log('Installing uv package manager...');
+      await runCommand('curl -LsSf https://astral.sh/uv/install.sh | sh', 'uv');
+
+      // Add uv to PATH for current session
+      const uvPath = path.join(process.env.HOME || '', '.cargo', 'bin');
+      process.env.PATH = `${uvPath}:${process.env.PATH}`;
+    } else {
+      console.log('✓ uv is already installed');
+    }
+
+    // Check Python 3.12
+    if (!checkCommand('python3.12 --version')) {
+      console.error('Python 3.12 is required but not found');
+      console.log('Please install Python 3.12 manually:');
+      console.log('  macOS: brew install python@3.12');
+      console.log('  Ubuntu/Debian: sudo apt install python3.12');
+      console.log('  Or visit: https://www.python.org/downloads/');
+      process.exit(1);
+    } else {
+      console.log('✓ Python 3.12 is available');
+    }
+
+    // Create virtual environment
+    console.log('Creating Python virtual environment...');
+    execSync(`uv venv --python 3.12 ${VENV_DIR}`, { stdio: 'inherit' });
+    console.log('✓ Virtual environment created');
+
+    // Install browser-use in the venv
+    console.log('Installing browser-use package...');
+    execSync(`uv pip install --python ${path.join(process.cwd(), VENV_DIR, 'bin', 'python')} browser-use`, {
+      stdio: 'inherit',
+    });
+    console.log('✓ browser-use installed');
+
+    // Install Playwright Chromium
+    console.log('Installing Playwright Chromium browser...');
+    execSync(`uvx playwright install chromium --with-deps`, { stdio: 'inherit' });
+    console.log('✓ Playwright Chromium installed');
+
+    // Create setup marker file
+    const setupMarkerPath = path.join(process.cwd(), SETUP_MARKER_FILE);
+    const setupInfo = {
+      version: '1.0.0',
+      setupDate: new Date().toISOString(),
+      packages: REQUIRED_PACKAGES.map((p) => p.name),
+      venvPath: VENV_DIR,
+    };
+    fs.writeFileSync(setupMarkerPath, JSON.stringify(setupInfo, null, 2));
+
+    // Add to .gitignore if not already there
+    const gitignorePath = path.join(process.cwd(), '.gitignore');
+    if (fs.existsSync(gitignorePath)) {
+      const gitignoreContent = fs.readFileSync(gitignorePath, 'utf8');
+      const itemsToIgnore = [VENV_DIR, SETUP_MARKER_FILE, 'downloads/'];
+      const linesToAdd: string[] = [];
+
+      itemsToIgnore.forEach((item) => {
+        if (!gitignoreContent.includes(item)) {
+          linesToAdd.push(item);
+        }
+      });
+
+      if (linesToAdd.length > 0) {
+        const newContent = gitignoreContent.trimEnd() + '\n\n# Minded Local Operator\n' + linesToAdd.join('\n') + '\n';
+        fs.writeFileSync(gitignorePath, newContent);
+        console.log('✓ Updated .gitignore');
+      }
+    }
+
+    // Add BROWSER_TASK_MODE to .env file
+    const envPath = path.join(process.cwd(), '.env');
+    const browserTaskModeVar = 'BROWSER_TASK_MODE=localRun';
+
+    if (fs.existsSync(envPath)) {
+      const envContent = fs.readFileSync(envPath, 'utf8');
+
+      // Check if BROWSER_TASK_MODE is already set
+      if (!envContent.includes('BROWSER_TASK_MODE')) {
+        // Append to existing .env file
+        const newEnvContent = envContent.trimEnd() + '\n' + browserTaskModeVar + '\n';
+        fs.writeFileSync(envPath, newEnvContent);
+        console.log('✓ Added BROWSER_TASK_MODE=localRun to .env');
+      } else if (!envContent.includes('BROWSER_TASK_MODE=localRun')) {
+        // BROWSER_TASK_MODE exists but with different value, update it
+        const updatedEnvContent = envContent.replace(/BROWSER_TASK_MODE=.*$/m, browserTaskModeVar);
+        fs.writeFileSync(envPath, updatedEnvContent);
+        console.log('✓ Updated BROWSER_TASK_MODE to localRun in .env');
+      } else {
+        console.log('✓ BROWSER_TASK_MODE=localRun already configured in .env');
+      }
+    } else {
+      // Create new .env file
+      fs.writeFileSync(envPath, browserTaskModeVar + '\n');
+      console.log('✓ Created .env file with BROWSER_TASK_MODE=localRun');
+    }
+
+    console.log('\n' + '='.repeat(50));
+    console.log('✅ Local operator setup completed successfully!');
+    console.log('='.repeat(50) + '\n');
+
+    console.log('You can now use browser automation features locally.');
+    console.log('The virtual environment will be activated automatically when needed.');
+  } catch (error) {
+    console.error('Setup failed:', error);
+
+    // Clean up partial installation
+    try {
+      if (fs.existsSync(path.join(process.cwd(), VENV_DIR))) {
+        fs.rmSync(path.join(process.cwd(), VENV_DIR), { recursive: true });
+      }
+    } catch {
+      // Ignore cleanup errors
+    }
+
+    process.exit(1);
+  }
+}
+
+export function validateLocalOperatorSetup(): void {
+  if (!isLocalOperatorSetup()) {
+    console.error('Local operator is not set up');
+    console.log('Please run: npx minded setup-local-operator');
+    throw new Error('Local operator not configured');
+  }
+}
+
+export function getVenvPath(): string {
+  return path.join(process.cwd(), VENV_DIR);
+}
+
+export function getVenvBinPath(): string {
+  return path.join(getVenvPath(), 'bin');
+}

package/src/nodes/addBrowserTaskNode.ts

@@ -31,10 +31,10 @@ export const addBrowserTaskNode = async ({ graph, node, agent, llm }: AddBrowser
     const zodSchema = createZodSchemaFromFields(node.inputSchema);
 
     // Create langchain tool
-    const tool = langchainTool(() => { }, {
+    const tool = langchainTool(() => {}, {
       name: 'browser-task',
       description: node.prompt,
-      schema: zodSchema,
+      schema: zodSchema as any,
     });
 
     const combinedPlaybooks = combinePlaybooks(agent.playbooks);

package/src/types/LLM.types.ts

@@ -9,7 +9,7 @@ export type LLMConfig = {
 export type LLMProvider = 'ChatOpenAI' | 'AzureChatOpenAI' | 'MindedChatOpenAI';
 
 export const LLMProviders: Record<LLMProvider, any> = {
-  ChatOpenAI: ChatOpenAI,
-  AzureChatOpenAI: AzureChatOpenAI,
+  ChatOpenAI,
+  AzureChatOpenAI,
   MindedChatOpenAI,
 };