@alook/cli 0.0.23 → 0.0.25

package/dist/meeting-runner.js

@@ -0,0 +1,562 @@
+// daemon/meeting-runner.ts
+import { chromium } from "playwright-core";
+
+// ../shared/src/browser/caption-scraper.ts
+function stripHtml(html) {
+  return html.replace(/<[^>]*>/g, "").trim();
+}
+function parseCaptionElements(elements) {
+  const results = [];
+  for (const el of elements) {
+    const speaker = stripHtml(el.speakerHtml);
+    const text = stripHtml(el.textHtml);
+    if (!speaker || !text)
+      continue;
+    results.push({ speaker, text });
+  }
+  return results;
+}
+function buildCaptionObserverScript() {
+  return `
+    (() => {
+      if (window.__alookCaptionObserver) return;
+      window.__alookCaptionObserver = true;
+      window.__alookCaptions = [];
+      window.__alookLastCaption = '';
+
+      const observer = new MutationObserver(() => {
+        // On any DOM change, scan for caption content.
+        // Google Meet renders captions as overlays with img (avatar) + text.
+        // The text mutates in-place (characterData), so we snapshot on every change.
+        const imgs = document.querySelectorAll('img');
+        for (const img of imgs) {
+          let entry = img.parentElement;
+          // Walk up to find the caption entry container
+          for (let i = 0; i < 4 && entry; i++) {
+            const text = entry.textContent || '';
+            if (text.length > 3 && entry.querySelectorAll('img').length === 1) break;
+            entry = entry.parentElement;
+          }
+          if (!entry) continue;
+
+          // Check this looks like a caption (has img + non-button text)
+          const parts = [];
+          const walker = document.createTreeWalker(entry, NodeFilter.SHOW_TEXT);
+          let node;
+          while (node = walker.nextNode()) {
+            let inBtn = false;
+            let p = node.parentElement;
+            while (p && p !== entry) {
+              if (p.tagName === 'BUTTON') { inBtn = true; break; }
+              p = p.parentElement;
+            }
+            if (inBtn) continue;
+            const t = node.textContent.trim();
+            if (t.length > 0 && t.length < 500) parts.push(t);
+          }
+
+          if (parts.length < 2 || parts[0].length > 40) continue;
+
+          const speaker = parts[0];
+          const text = parts.slice(1).join(' ');
+          const key = speaker + '::' + text;
+
+          // Filter out UI elements misidentified as captions
+          const lower = text.toLowerCase();
+          if (lower.includes('background') || lower.includes('effects') || lower.includes('devices') ||
+              lower.includes('more options') || lower.includes('still see your') ||
+              lower.includes('settings') || lower.includes('reframe')) continue;
+
+          // Only record if text changed from last snapshot
+          if (key !== window.__alookLastCaption) {
+            window.__alookLastCaption = key;
+            window.__alookCaptions.push({
+              speakerHtml: speaker,
+              textHtml: text,
+              ts: Date.now(),
+            });
+          }
+        }
+      });
+
+      observer.observe(document.body, { childList: true, subtree: true, characterData: true });
+    })()
+  `.trim();
+}
+function buildCaptionScrapeScript() {
+  return `
+    (() => {
+      const result = window.__alookCaptions || [];
+      window.__alookCaptions = [];
+      return result.map(c => ({ speakerHtml: c.speakerHtml, textHtml: c.textHtml }));
+    })()
+  `.trim();
+}
+// ../shared/src/browser/transcript.ts
+function createTimestamp(startMs, currentMs) {
+  const elapsed = Math.max(0, currentMs - startMs);
+  const totalSeconds = Math.floor(elapsed / 1000);
+  const hours = Math.floor(totalSeconds / 3600);
+  const minutes = Math.floor(totalSeconds % 3600 / 60);
+  const seconds = totalSeconds % 60;
+  return `${String(hours).padStart(2, "0")}:${String(minutes).padStart(2, "0")}:${String(seconds).padStart(2, "0")}`;
+}
+function deduplicateCaptions(existing, incoming, meetingStartMs, nowMs) {
+  const timestamp = createTimestamp(meetingStartMs, nowMs);
+  const newEntries = [];
+  for (const cap of incoming) {
+    const last = existing.length > 0 ? existing[existing.length - 1] : null;
+    if (last && last.speaker === cap.speaker && last.text === cap.text) {
+      continue;
+    }
+    if (last && last.speaker === cap.speaker && cap.text.startsWith(last.text)) {
+      last.text = cap.text;
+      continue;
+    }
+    newEntries.push({
+      speaker: cap.speaker,
+      text: cap.text,
+      timestamp
+    });
+  }
+  return [...existing, ...newEntries];
+}
+function groupIntoBlocks(entries) {
+  const blocks = [];
+  for (const entry of entries) {
+    const lastBlock = blocks.length > 0 ? blocks[blocks.length - 1] : null;
+    if (lastBlock && lastBlock.speaker === entry.speaker) {
+      lastBlock.lines.push(entry.text);
+    } else {
+      blocks.push({
+        speaker: entry.speaker,
+        lines: [entry.text],
+        startTimestamp: entry.timestamp
+      });
+    }
+  }
+  return blocks;
+}
+function formatTranscript(entries) {
+  if (entries.length === 0)
+    return "";
+  const blocks = groupIntoBlocks(entries);
+  return blocks.map((block) => `[${block.startTimestamp}] ${block.speaker}:
+${block.lines.join(`
+`)}`).join(`
+
+`);
+}
+// ../shared/src/browser/meet-navigator.ts
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function dismissDialogs(page) {
+  for (let i = 0;i < 3; i++) {
+    try {
+      const dialogBtn = await page.$('[role="dialog"] button, [role="alertdialog"] button, [role="alert"] button');
+      if (dialogBtn) {
+        await dialogBtn.click();
+        await delay(300);
+        continue;
+      }
+    } catch {}
+    break;
+  }
+}
+async function detectBlocked(page) {
+  const blocked = await page.evaluate(() => {
+    const text = document.body?.innerText || "";
+    if (text.includes("can't join") || text.includes("unable to join") || text.includes("无法加入")) {
+      return text.slice(0, 200);
+    }
+    return null;
+  });
+  if (blocked) {
+    throw new Error(`Blocked from joining: ${blocked}`);
+  }
+}
+async function joinMeeting(page, meetingUrl, botName) {
+  await page.goto(meetingUrl, { waitUntil: "domcontentloaded", timeout: 30000 });
+  await delay(2000);
+  await detectBlocked(page);
+  await dismissDialogs(page);
+  try {
+    const nameInput = await page.waitForSelector('input[aria-label="Your name"]', { timeout: 1e4 });
+    if (nameInput) {
+      await nameInput.click({ clickCount: 3 });
+      await nameInput.type(botName);
+    }
+  } catch {}
+  await page.evaluate(() => {
+    const btns = document.querySelectorAll("button");
+    for (const btn of btns) {
+      const label = (btn.getAttribute("aria-label") || "").toLowerCase();
+      const muted = btn.getAttribute("data-is-muted");
+      if (muted === "false" && (label.includes("microphone") || label.includes("camera"))) {
+        btn.click();
+        continue;
+      }
+      if (label.startsWith("turn off") && (label.includes("microphone") || label.includes("camera"))) {
+        btn.click();
+      }
+    }
+  });
+  const joined = await page.evaluate(() => {
+    const deadline = Date.now() + 15000;
+    return new Promise((resolve) => {
+      const check = () => {
+        const btns = document.querySelectorAll("button:not([disabled])");
+        for (const btn of btns) {
+          const text = (btn.textContent || "").toLowerCase();
+          if (text.includes("join") || text.includes("加入")) {
+            if (text.includes("other") || text.includes("其他"))
+              continue;
+            btn.click();
+            return resolve(true);
+          }
+        }
+        if (Date.now() < deadline)
+          setTimeout(check, 500);
+        else
+          resolve(false);
+      };
+      check();
+    });
+  });
+  if (!joined)
+    throw new Error("Join button not found or remained disabled");
+  await delay(3000);
+  await detectBlocked(page);
+}
+async function enableCaptions(page) {
+  const clicked = await page.evaluate(() => {
+    const btns = document.querySelectorAll("button");
+    for (const btn of btns) {
+      const label = (btn.getAttribute("aria-label") || "").toLowerCase();
+      const text = (btn.textContent || "").toLowerCase();
+      if (label.includes("caption") || label.includes("subtitle") || label.includes("字幕") || text.includes("closed_caption")) {
+        btn.click();
+        return true;
+      }
+    }
+    return false;
+  });
+  if (clicked) {
+    await delay(2000);
+  }
+}
+async function waitForMeetingReady(page, timeoutMs = 60000) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    const state = await page.evaluate(() => {
+      const text = document.body?.innerText || "";
+      if (text.includes("Please wait") || text.includes("请等待"))
+        return "waiting";
+      if (text.includes("can't join") || text.includes("无法加入"))
+        return "blocked";
+      const inCall = document.querySelector('button[aria-label*="Leave call" i], button[aria-label="退出通话"]');
+      const waiting = document.querySelector('[aria-label*="wait" i]');
+      if (inCall && !waiting)
+        return "ready";
+      return "loading";
+    });
+    if (state === "ready")
+      return;
+    if (state === "blocked")
+      throw new Error("Blocked from joining meeting");
+    await delay(2000);
+  }
+  throw new Error("Timed out waiting to be admitted to meeting");
+}
+function buildAloneDetectorScript() {
+  return `
+    (() => {
+      if (window.__alookAloneDetector) return;
+      window.__alookAloneDetector = true;
+      window.__alookAlone = false;
+
+      const keywords = ['only one here', 'no one else', 'everyone has left',
+                         '只有你', '没有其他人', '所有人都已离开'];
+
+      const observer = new MutationObserver((mutations) => {
+        for (const m of mutations) {
+          for (const node of m.addedNodes) {
+            if (node.nodeType !== 1) continue;
+            const text = (node.textContent || '').toLowerCase();
+            for (const kw of keywords) {
+              if (text.includes(kw)) {
+                window.__alookAlone = true;
+                return;
+              }
+            }
+          }
+        }
+      });
+      observer.observe(document.body, { childList: true, subtree: true });
+    })()
+  `.trim();
+}
+async function isMeetingActive(page) {
+  try {
+    return await page.evaluate(() => {
+      const leaveBtn = document.querySelector('button[aria-label="Leave call" i], button[aria-label*="hang up" i]');
+      if (!leaveBtn)
+        return false;
+      if (window.__alookAlone)
+        return false;
+      return true;
+    });
+  } catch {
+    return false;
+  }
+}
+async function leaveMeeting(page) {
+  try {
+    const leaveButton = await page.$('button[aria-label="Leave call" i], button[aria-label*="hang up" i]');
+    if (leaveButton) {
+      await leaveButton.click();
+      await delay(2000);
+    }
+  } catch {}
+}
+// ../shared/src/browser/chrome-finder.ts
+import { existsSync } from "node:fs";
+import { execSync } from "node:child_process";
+var CHROME_PATHS = {
+  darwin: [
+    "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+    "/Applications/Google Chrome Canary.app/Contents/MacOS/Google Chrome Canary",
+    "/Applications/Chromium.app/Contents/MacOS/Chromium"
+  ],
+  linux: [
+    "/usr/bin/google-chrome",
+    "/usr/bin/google-chrome-stable",
+    "/usr/bin/chromium-browser",
+    "/usr/bin/chromium",
+    "/snap/bin/chromium"
+  ],
+  win32: [
+    "C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe",
+    "C:\\Program Files (x86)\\Google\\Chrome\\Application\\chrome.exe",
+    `${process.env.LOCALAPPDATA}\\Google\\Chrome\\Application\\chrome.exe`
+  ]
+};
+function findChrome() {
+  const platform = process.platform;
+  const candidates = CHROME_PATHS[platform] ?? [];
+  for (const p of candidates) {
+    if (existsSync(p))
+      return p;
+  }
+  if (platform === "linux") {
+    try {
+      const result = execSync("which google-chrome || which chromium", { encoding: "utf8" }).trim();
+      if (result)
+        return result;
+    } catch {}
+  }
+  return findPlaywrightChromium();
+}
+function findPlaywrightChromium() {
+  try {
+    const result = execSync("npx playwright install --dry-run chromium 2>&1", { encoding: "utf8" });
+    const match = result.match(/browser binaries.*?:\s*(.+)/i);
+    if (match) {
+      const dir = match[1].trim();
+      const chromePaths = [
+        `${dir}/chrome-linux/chrome`,
+        `${dir}/chrome-mac/Chromium.app/Contents/MacOS/Chromium`,
+        `${dir}/chrome-win/chrome.exe`
+      ];
+      for (const p of chromePaths) {
+        if (existsSync(p))
+          return p;
+      }
+    }
+  } catch {}
+  return null;
+}
+function ensureChrome() {
+  const existing = findChrome();
+  if (existing)
+    return existing;
+  execSync("npx playwright install chromium", {
+    stdio: "inherit",
+    timeout: 120000
+  });
+  const installed = findChrome();
+  if (!installed)
+    throw new Error("Failed to install Chromium via Playwright");
+  return installed;
+}
+// daemon/meeting-runner.ts
+var SCRAPE_INTERVAL_MS = 3000;
+var BOT_NAME = "Alook Meeting Bot";
+var MAX_RETRY_DURATION_MS = 30 * 60 * 1000;
+var RETRY_BACKOFF = [30000, 60000, 120000, 300000];
+function log(msg) {
+  console.log(`[meeting-runner] ${new Date().toISOString()} ${msg}`);
+}
+async function callbackWeb(input, status, transcript, error) {
+  const payload = JSON.stringify({
+    meetingId: input.meetingId,
+    workspaceId: input.workspaceId,
+    status,
+    transcript: transcript || undefined,
+    error: error || undefined
+  });
+  try {
+    const res = await fetch(`${input.callbackUrl}/api/meeting/callback`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${input.authToken}`
+      },
+      body: payload
+    });
+    log(`Callback ${status} → ${res.status}`);
+  } catch (err) {
+    log(`Callback failed: ${err instanceof Error ? err.message : err}`);
+  }
+}
+function launchBrowser(chromePath) {
+  return chromium.launch({
+    executablePath: chromePath,
+    headless: false,
+    args: [
+      "--lang=en-US",
+      "--disable-blink-features=AutomationControlled",
+      "--use-fake-ui-for-media-stream",
+      "--use-fake-device-for-media-stream",
+      "--disable-audio-output"
+    ]
+  });
+}
+async function tryJoinAndRecord(input, chromePath) {
+  const browser = await launchBrowser(chromePath);
+  const context = browser.contexts()[0];
+  if (context) {
+    await context.addInitScript(() => {
+      Object.defineProperty(navigator, "webdriver", { get: () => false });
+    });
+  }
+  const page = await browser.newPage({ locale: "en-US" });
+  const meetingStartMs = Date.now();
+  let transcript = [];
+  try {
+    await joinMeeting(page, input.meetingUrl, BOT_NAME);
+    log("Joined. Waiting for meeting UI...");
+    await waitForMeetingReady(page);
+    await page.evaluate(() => {
+      for (const btn of document.querySelectorAll("button")) {
+        const label = (btn.getAttribute("aria-label") || "").toLowerCase();
+        if (label.startsWith("turn off") && (label.includes("microphone") || label.includes("camera"))) {
+          btn.click();
+        }
+      }
+    });
+    log("Meeting ready. Enabling captions...");
+    await enableCaptions(page);
+    await page.evaluate(buildCaptionObserverScript());
+    await page.evaluate(buildAloneDetectorScript());
+    log("Captions enabled, observer injected. Scraping loop started.");
+    let scrapeCount = 0;
+    while (true) {
+      try {
+        const active = await isMeetingActive(page);
+        if (!active) {
+          const finalRaw = await page.evaluate(buildCaptionScrapeScript());
+          const finalCaptions = parseCaptionElements(finalRaw);
+          if (finalCaptions.length > 0) {
+            transcript = deduplicateCaptions(transcript, finalCaptions, meetingStartMs, Date.now());
+            log(`Final scrape: ${finalCaptions.length} caption(s), total ${transcript.length}`);
+          }
+          log("Meeting ended (no longer active)");
+          break;
+        }
+        const rawElements = await page.evaluate(buildCaptionScrapeScript());
+        const captions = parseCaptionElements(rawElements);
+        scrapeCount++;
+        if (captions.length > 0) {
+          const prevLen = transcript.length;
+          transcript = deduplicateCaptions(transcript, captions, meetingStartMs, Date.now());
+          if (transcript.length > prevLen) {
+            log(`Caption: ${captions[captions.length - 1].speaker}: "${captions[captions.length - 1].text}" (total ${transcript.length})`);
+          }
+        } else if (scrapeCount <= 5) {
+          log(`Scrape #${scrapeCount}: no captions yet`);
+        }
+      } catch (err) {
+        log(`Scrape error: ${err instanceof Error ? err.message : err}`);
+        break;
+      }
+      await new Promise((resolve) => setTimeout(resolve, SCRAPE_INTERVAL_MS));
+    }
+    await leaveMeeting(page);
+    return { status: "completed", transcript };
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    if (msg.includes("Blocked from joining")) {
+      const screenshotPath = `/tmp/meeting-${input.meetingId}-blocked.png`;
+      await page.screenshot({ path: screenshotPath }).catch(() => {});
+      log(`Blocked — screenshot: ${screenshotPath}`);
+      return { status: "blocked", transcript, error: msg };
+    }
+    log(`Error: ${msg}`);
+    return { status: "error", transcript, error: msg };
+  } finally {
+    await page.close().catch(() => {});
+    await browser.close().catch(() => {});
+  }
+}
+async function run(input) {
+  log(`Starting: ${input.meetingUrl} (${input.meetingId})`);
+  let chromePath;
+  try {
+    chromePath = ensureChrome();
+    log(`Chrome found: ${chromePath}`);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    log(`Chrome setup failed: ${msg}`);
+    await callbackWeb(input, "failed", undefined, `Chrome setup failed: ${msg}`);
+    process.exit(1);
+  }
+  const startTime = Date.now();
+  let attempt = 0;
+  while (true) {
+    attempt++;
+    log(attempt > 1 ? `Retry attempt #${attempt}...` : "Launching browser (en-US, stealth)...");
+    const result = await tryJoinAndRecord(input, chromePath);
+    if (result.status === "completed") {
+      const transcriptText = formatTranscript(result.transcript);
+      log(`Completed: ${result.transcript.length} transcript entries`);
+      await callbackWeb(input, "completed", transcriptText);
+      return;
+    }
+    if (result.status === "blocked") {
+      const elapsed = Date.now() - startTime;
+      if (elapsed >= MAX_RETRY_DURATION_MS) {
+        log(`Giving up after ${Math.round(elapsed / 60000)}min of retries`);
+        await callbackWeb(input, "failed", undefined, result.error);
+        return;
+      }
+      const backoff = RETRY_BACKOFF[Math.min(attempt - 1, RETRY_BACKOFF.length - 1)];
+      log(`Blocked, retrying in ${backoff / 1000}s (attempt ${attempt}, ${Math.round(elapsed / 60000)}min elapsed)`);
+      await new Promise((resolve) => setTimeout(resolve, backoff));
+      continue;
+    }
+    await callbackWeb(input, "failed", undefined, result.error);
+    return;
+  }
+}
+var encoded = process.argv[2];
+if (!encoded) {
+  console.error("Usage: meeting-runner <base64-encoded-input>");
+  process.exit(1);
+}
+var input = JSON.parse(Buffer.from(encoded, "base64").toString("utf-8"));
+run(input).then(() => process.exit(0)).catch((err) => {
+  log(`Fatal: ${err instanceof Error ? err.message : err}`);
+  process.exit(1);
+});