halo-agent 1.1.0

package/manusAutomate.js

@@ -0,0 +1,349 @@
+'use strict';
+
+/**
+ * manusAutomate.js
+ *
+ * Uses Playwright (connected to the user's real Chrome via CDP) to:
+ * 1. Open manus.im/app
+ * 2. Click "New Task" to create a task
+ * 3. Paste the generated prompt into the task input
+ * 4. Click Send / Submit
+ * 5. Extract the resulting Manus task URL / ID
+ * 6. Poll Manus task progress and report status back to HALO
+ */
+
+const { chromium } = require('playwright');
+
+const CDP_URL = 'http://localhost:9222';
+const MANUS_APP_URL = 'https://manus.im/app';
+
+/**
+ * Connect to the user's real Chrome via CDP.
+ * Returns a Playwright browser object connected to the existing Chrome session.
+ */
+async function connectChrome() {
+  const browser = await chromium.connectOverCDP(CDP_URL);
+  const context = browser.contexts()[0] || await browser.newContext();
+  return { browser, context };
+}
+
+/**
+ * Navigate to manus.im/app, click New Task, paste the prompt, and submit.
+ * Returns the Manus task URL and task ID extracted from the resulting page.
+ *
+ * @param {string} prompt - Full task prompt to paste into Manus
+ * @param {object} chromeConn - { browser, context } from connectChrome()
+ * @returns {{ taskUrl: string, taskId: string } | { error: string }}
+ */
+async function dispatchManusTask(prompt, chromeConn) {
+  const { context } = chromeConn;
+  let page = null;
+
+  try {
+    // Open a new tab to manus.im/app
+    page = await context.newPage();
+    console.log('[manus-automate] Navigating to manus.im/app...');
+    await page.goto(MANUS_APP_URL, { waitUntil: 'domcontentloaded', timeout: 30000 });
+    await page.waitForTimeout(2000); // let React/SPA hydrate
+
+    // Wait for the page to be usable — look for a "New Task" button or chat input
+    // Manus UI may show a task list or a blank home state
+    console.log('[manus-automate] Looking for New Task button...');
+
+    // Try multiple selectors for "New Task" button (Manus UI may vary)
+    const newTaskSelectors = [
+      'button:has-text("New Task")',
+      'button:has-text("New task")',
+      'a:has-text("New Task")',
+      '[aria-label="New Task"]',
+      '[data-testid="new-task-button"]',
+      'button:has-text("New")',
+    ];
+
+    let clicked = false;
+    for (const sel of newTaskSelectors) {
+      try {
+        const el = page.locator(sel).first();
+        const visible = await el.isVisible({ timeout: 3000 });
+        if (visible) {
+          await el.click();
+          console.log(`[manus-automate] Clicked New Task (selector: ${sel})`);
+          clicked = true;
+          await page.waitForTimeout(1500);
+          break;
+        }
+      } catch {}
+    }
+
+    // If no "New Task" button found, we may already be on a blank task input page
+    if (!clicked) {
+      console.log('[manus-automate] No New Task button found — assuming already on task input page');
+    }
+
+    // Find the task input textarea or contenteditable
+    console.log('[manus-automate] Looking for task input field...');
+    const inputSelectors = [
+      'textarea[placeholder*="task"]',
+      'textarea[placeholder*="Task"]',
+      'textarea[placeholder*="message"]',
+      'textarea[placeholder*="Message"]',
+      'div[contenteditable="true"]',
+      'textarea',
+      '[role="textbox"]',
+    ];
+
+    let inputEl = null;
+    for (const sel of inputSelectors) {
+      try {
+        const el = page.locator(sel).first();
+        const visible = await el.isVisible({ timeout: 3000 });
+        if (visible) {
+          inputEl = el;
+          console.log(`[manus-automate] Found input (selector: ${sel})`);
+          break;
+        }
+      } catch {}
+    }
+
+    if (!inputEl) {
+      // Take a screenshot for debugging
+      const shot = await page.screenshot({ type: 'jpeg', quality: 60 }).catch(() => null);
+      if (shot) {
+        const fs = require('fs');
+        const path = require('path');
+        const shotPath = path.join(require('os').tmpdir(), 'manus_debug.jpg');
+        fs.writeFileSync(shotPath, shot);
+        console.warn(`[manus-automate] Debug screenshot saved to: ${shotPath}`);
+      }
+      throw new Error('Could not find task input field on manus.im/app');
+    }
+
+    // Click the input to focus it
+    await inputEl.click();
+    await page.waitForTimeout(300);
+
+    // Clear any existing content
+    await page.keyboard.press('Control+A');
+    await page.keyboard.press('Delete');
+    await page.waitForTimeout(200);
+
+    // Type the prompt using clipboard paste for speed and accuracy
+    // (direct typing would take forever on a 3000+ char prompt)
+    console.log('[manus-automate] Pasting prompt into input...');
+
+    // Set clipboard value via page.evaluate and then Ctrl+V
+    await page.evaluate((text) => {
+      // Write to clipboard using the clipboard API
+      return navigator.clipboard.writeText(text).catch(() => {
+        // Fallback: create a temp textarea, copy from it
+        const ta = document.createElement('textarea');
+        ta.value = text;
+        document.body.appendChild(ta);
+        ta.select();
+        document.execCommand('copy');
+        document.body.removeChild(ta);
+      });
+    }, prompt);
+
+    await page.waitForTimeout(300);
+    await inputEl.click();
+    await page.waitForTimeout(200);
+    await page.keyboard.press('Meta+V'); // Cmd+V on macOS
+    await page.waitForTimeout(800);
+
+    // Verify text was entered (check input value or text content)
+    let hasContent = false;
+    try {
+      const tagName = await inputEl.evaluate(el => el.tagName.toLowerCase());
+      if (tagName === 'textarea') {
+        const val = await inputEl.inputValue();
+        hasContent = val.length > 100;
+      } else {
+        const text = await inputEl.innerText();
+        hasContent = text.length > 100;
+      }
+    } catch {}
+
+    if (!hasContent) {
+      // Fallback: try typing a small prefix to trigger the input, then paste
+      console.warn('[manus-automate] Paste may have failed — trying Control+V fallback');
+      await inputEl.click();
+      await page.keyboard.press('Control+V'); // Linux/Windows fallback
+      await page.waitForTimeout(800);
+    }
+
+    console.log('[manus-automate] Prompt entered. Looking for Send button...');
+
+    // Find and click the Send / Submit button
+    const sendSelectors = [
+      'button[type="submit"]',
+      'button:has-text("Send")',
+      'button:has-text("Run")',
+      'button:has-text("Submit")',
+      'button:has-text("Start")',
+      '[aria-label="Send"]',
+      '[aria-label="Run task"]',
+      '[data-testid="send-button"]',
+    ];
+
+    let sent = false;
+    for (const sel of sendSelectors) {
+      try {
+        const el = page.locator(sel).first();
+        const enabled = await el.isEnabled({ timeout: 2000 });
+        const visible = await el.isVisible({ timeout: 1000 });
+        if (enabled && visible) {
+          await el.click();
+          console.log(`[manus-automate] Clicked Send (selector: ${sel})`);
+          sent = true;
+          break;
+        }
+      } catch {}
+    }
+
+    if (!sent) {
+      // Try pressing Enter in the input as a fallback
+      console.warn('[manus-automate] No Send button found — pressing Enter');
+      await inputEl.press('Enter');
+      sent = true;
+    }
+
+    // Wait for Manus to accept the task and navigate to a task URL
+    // The URL typically becomes something like manus.im/app/session/XXXXX
+    console.log('[manus-automate] Waiting for task to be created...');
+    await page.waitForTimeout(3000);
+
+    // Try to detect the task URL from the current page URL
+    let taskUrl = page.url();
+    let taskId = null;
+
+    // Poll up to 15s for the URL to change to a task-specific URL
+    for (let i = 0; i < 15; i++) {
+      const currentUrl = page.url();
+      const taskMatch = currentUrl.match(/manus\.im\/app\/(?:session|task)\/([a-zA-Z0-9_-]+)/);
+      if (taskMatch) {
+        taskUrl = currentUrl;
+        taskId = taskMatch[1];
+        console.log(`[manus-automate] Task created: ${taskUrl}`);
+        break;
+      }
+      await page.waitForTimeout(1000);
+    }
+
+    if (!taskId) {
+      // Try to extract task ID from page content (Manus may store it in DOM)
+      try {
+        taskId = await page.evaluate(() => {
+          // Look for task ID in URL, data attributes, or text
+          const url = window.location.href;
+          const m = url.match(/\/(?:session|task)\/([a-zA-Z0-9_-]+)/);
+          if (m) return m[1];
+
+          // Try meta tags or window state
+          const metaTaskId = document.querySelector('[data-task-id]');
+          if (metaTaskId) return metaTaskId.getAttribute('data-task-id');
+
+          return null;
+        });
+      } catch {}
+    }
+
+    if (!taskId) {
+      console.warn('[manus-automate] Could not extract task ID — task may still have been created');
+      // Return the current URL as best effort
+      return { taskUrl: page.url(), taskId: null };
+    }
+
+    return { taskUrl, taskId };
+  } finally {
+    // Don't close the page — let the user see Manus running in their browser
+    // page.close() would be rude here
+  }
+}
+
+/**
+ * Poll a Manus task for status updates and report them back to HALO.
+ * Runs for up to 2 hours before giving up.
+ *
+ * @param {string} taskId - Manus task session/task ID
+ * @param {string} queueId - HALO apply_queue row ID
+ * @param {object} config - halo-agent config ({ apiUrl, token })
+ */
+async function pollManusTaskStatus(taskId, queueId, config) {
+  console.log(`[manus-automate] Polling Manus task ${taskId} for completion...`);
+
+  const POLL_INTERVAL = 10000; // 10s
+  const MAX_POLLS = 720; // 2 hours max
+
+  for (let i = 0; i < MAX_POLLS; i++) {
+    await new Promise(r => setTimeout(r, POLL_INTERVAL));
+
+    try {
+      // Ask HALO backend to check Manus task status (HALO holds the API key)
+      const res = await fetch(`${config.apiUrl}/manus/status/${taskId}`, {
+        headers: { Authorization: `Bearer ${config.token}` },
+      });
+
+      if (!res.ok) {
+        console.warn(`[manus-automate] Status poll failed (${res.status}) — retrying`);
+        continue;
+      }
+
+      const data = await res.json();
+      const status = (data.status || '').toLowerCase();
+
+      console.log(`[manus-automate] Task ${taskId} status: ${status} (poll ${i + 1})`);
+
+      // Map Manus status to HALO queue status
+      if (status === 'completed' || status === 'done' || status === 'finished') {
+        await reportQueueStatus(config, queueId, 'DONE');
+        console.log(`[manus-automate] Task ${taskId} completed successfully.`);
+        return 'DONE';
+      }
+
+      if (status === 'failed' || status === 'error') {
+        await reportQueueStatus(config, queueId, 'NEEDS_ATTENTION', {
+          needs_attention_reason: 'Manus task failed. Check manus.im for details.',
+        });
+        return 'NEEDS_ATTENTION';
+      }
+
+      if (status === 'cancelled') {
+        await reportQueueStatus(config, queueId, 'CANCELLED');
+        return 'CANCELLED';
+      }
+
+      // Still running — update HALO with latest message snippet
+      const latestMsg = (data.recentMessages || [])[0];
+      if (latestMsg?.content) {
+        const snippet = String(latestMsg.content).slice(0, 200);
+        await reportQueueStatus(config, queueId, 'IN_PROGRESS', { progress_note: snippet });
+      }
+    } catch (e) {
+      console.warn(`[manus-automate] Poll error: ${e.message}`);
+    }
+  }
+
+  // Timed out
+  await reportQueueStatus(config, queueId, 'NEEDS_ATTENTION', {
+    needs_attention_reason: 'Manus task polling timed out after 2 hours. Check manus.im manually.',
+  });
+  return 'TIMEOUT';
+}
+
+async function reportQueueStatus(config, queueId, status, extra = {}) {
+  try {
+    await fetch(`${config.apiUrl}/apply-queue/${queueId}`, {
+      method: 'PATCH',
+      headers: {
+        Authorization: `Bearer ${config.token}`,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({ status, ...extra }),
+    });
+  } catch (e) {
+    console.warn(`[manus-automate] Could not report status ${status}:`, e.message);
+  }
+}
+
+module.exports = { connectChrome, dispatchManusTask, pollManusTaskStatus };