@alook/app 0.0.16 → 0.0.18

package/dist/cli/meeting-runner.js

@@ -0,0 +1,888 @@
+// 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
+import { join as join3 } from "path";
+import { mkdirSync as mkdirSync2 } from "fs";
+
+// lib/platform.ts
+import { tmpdir } from "os";
+import { join, sep } from "path";
+var isWindows = process.platform === "win32";
+function tempDir(subdir) {
+  return join(tmpdir(), subdir);
+}
+
+// lib/logger.ts
+var LEVELS = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3,
+  silent: 4
+};
+var LABELS = {
+  debug: "DEBUG",
+  info: "INFO ",
+  warn: "WARN ",
+  error: "ERROR"
+};
+var COLORS = {
+  debug: "\x1B[90m",
+  info: "\x1B[36m",
+  warn: "\x1B[33m",
+  error: "\x1B[31m"
+};
+var RESET = "\x1B[0m";
+var DIM = "\x1B[2m";
+var BOLD = "\x1B[1m";
+function useColor() {
+  if (process.env.NO_COLOR !== undefined)
+    return false;
+  if (process.env.FORCE_COLOR !== undefined)
+    return true;
+  return process.stdout.isTTY === true;
+}
+function timestamp() {
+  const d = new Date;
+  const Y = d.getFullYear();
+  const M = String(d.getMonth() + 1).padStart(2, "0");
+  const D = String(d.getDate()).padStart(2, "0");
+  const h = String(d.getHours()).padStart(2, "0");
+  const m = String(d.getMinutes()).padStart(2, "0");
+  const s = String(d.getSeconds()).padStart(2, "0");
+  return `${Y}-${M}-${D} ${h}:${m}:${s}`;
+}
+
+class Logger {
+  level;
+  color;
+  module;
+  constructor(opts = {}) {
+    const envLevel = process.env.ALOOK_LOG_LEVEL;
+    this.level = LEVELS[opts.level ?? envLevel ?? "info"];
+    this.color = useColor();
+    this.module = opts.module;
+  }
+  setLevel(level) {
+    this.level = LEVELS[level];
+  }
+  child(module) {
+    const child = new Logger({ level: this.levelName(), module });
+    return child;
+  }
+  debug(msg, ...args) {
+    this.write("debug", msg, args);
+  }
+  info(msg, ...args) {
+    this.write("info", msg, args);
+  }
+  warn(msg, ...args) {
+    this.write("warn", msg, args);
+  }
+  error(msg, ...args) {
+    this.write("error", msg, args);
+  }
+  levelName() {
+    for (const [name, num] of Object.entries(LEVELS)) {
+      if (num === this.level)
+        return name;
+    }
+    return "info";
+  }
+  write(level, msg, args) {
+    if (LEVELS[level] < this.level)
+      return;
+    const ts = timestamp();
+    const label = LABELS[level];
+    const mod = this.module ? `[${this.module}]` : "";
+    let line;
+    if (this.color) {
+      const c = COLORS[level];
+      const modStr = mod ? ` ${BOLD}${mod}${RESET}` : "";
+      line = `${DIM}${ts}${RESET} ${c}${label}${RESET}${modStr} ${msg}`;
+    } else {
+      const modStr = mod ? ` ${mod}` : "";
+      line = `${ts} ${label}${modStr} ${msg}`;
+    }
+    const dest = level === "error" ? process.stderr : process.stdout;
+    dest.write(line + `
+`);
+    for (const a of args) {
+      if (a instanceof Error) {
+        dest.write(`  ${a.message}
+`);
+        if (a.stack && this.level <= LEVELS.debug) {
+          dest.write(`  ${a.stack}
+`);
+        }
+      } else if (a !== null && typeof a === "object") {
+        const pairs = Object.entries(a).map(([k, v]) => `${k}=${typeof v === "object" ? JSON.stringify(v) : v}`).join(" ");
+        if (pairs)
+          dest.write(`  ${pairs}
+`);
+      } else if (a !== undefined) {
+        dest.write(`  ${String(a)}
+`);
+      }
+    }
+  }
+}
+function createLogger(opts) {
+  return new Logger(opts);
+}
+var log = createLogger();
+
+// daemon/execenv/timeline.ts
+import { appendFileSync, readFileSync, writeFileSync, renameSync } from "fs";
+import { join as join2 } from "path";
+
+// daemon/execenv/filelock.ts
+import { mkdirSync, rmdirSync, statSync } from "fs";
+var DEFAULT_STALE_MS = 3600000;
+function acquireLock(lockPath, staleMs = DEFAULT_STALE_MS) {
+  try {
+    mkdirSync(lockPath);
+    return true;
+  } catch {
+    try {
+      const stat = statSync(lockPath);
+      if (Date.now() - stat.mtimeMs > staleMs) {
+        rmdirSync(lockPath);
+        try {
+          mkdirSync(lockPath);
+          return true;
+        } catch {
+          return false;
+        }
+      }
+    } catch {
+      try {
+        mkdirSync(lockPath);
+        return true;
+      } catch {
+        return false;
+      }
+    }
+    return false;
+  }
+}
+function releaseLock(lockPath) {
+  try {
+    rmdirSync(lockPath);
+  } catch {}
+}
+
+// daemon/execenv/timeline.ts
+var log2 = createLogger({ module: "timeline" });
+function filenameForDate(date) {
+  const y = date.getFullYear();
+  const m = String(date.getMonth() + 1).padStart(2, "0");
+  const d = String(date.getDate()).padStart(2, "0");
+  return `${y}-${m}-${d}.jsonl`;
+}
+function todayFilename() {
+  return filenameForDate(new Date);
+}
+function recentFilenames(maxDays) {
+  const filenames = [];
+  const now = new Date;
+  for (let i = 0;i < maxDays; i++) {
+    const d = new Date(now);
+    d.setDate(d.getDate() - i);
+    filenames.push(filenameForDate(d));
+  }
+  return filenames;
+}
+function localISOString() {
+  const now = new Date;
+  const tzOffset = -now.getTimezoneOffset();
+  const sign = tzOffset >= 0 ? "+" : "-";
+  const absOffset = Math.abs(tzOffset);
+  const hh = String(Math.floor(absOffset / 60)).padStart(2, "0");
+  const mm = String(absOffset % 60).padStart(2, "0");
+  const y = now.getFullYear();
+  const mo = String(now.getMonth() + 1).padStart(2, "0");
+  const d = String(now.getDate()).padStart(2, "0");
+  const h = String(now.getHours()).padStart(2, "0");
+  const mi = String(now.getMinutes()).padStart(2, "0");
+  const s = String(now.getSeconds()).padStart(2, "0");
+  return `${y}-${mo}-${d}T${h}:${mi}:${s}${sign}${hh}:${mm}`;
+}
+function lockPathFor(timelineDir, filename) {
+  return join2(timelineDir, `.${filename}.lock`);
+}
+function initEntry(timelineDir, entry) {
+  const filename = todayFilename();
+  const filePath = join2(timelineDir, filename);
+  const lockPath = lockPathFor(timelineDir, filename);
+  try {
+    const acquired = acquireLock(lockPath);
+    if (!acquired) {
+      log2.debug(`Timeline initEntry: could not acquire lock for ${filename}`);
+      return;
+    }
+    try {
+      appendFileSync(filePath, JSON.stringify(entry) + `
+`);
+    } finally {
+      releaseLock(lockPath);
+    }
+  } catch (err) {
+    log2.debug("Timeline initEntry failed", err);
+  }
+}
+function updateEntry(timelineDir, taskId, updater) {
+  for (const filename of recentFilenames(7)) {
+    const filePath = join2(timelineDir, filename);
+    const lockPath = lockPathFor(timelineDir, filename);
+    try {
+      const acquired = acquireLock(lockPath);
+      if (!acquired) {
+        log2.debug(`Timeline updateEntry: lock held for ${filename}, skipping`);
+        continue;
+      }
+      try {
+        let content;
+        try {
+          content = readFileSync(filePath, "utf-8");
+        } catch {
+          continue;
+        }
+        const lines = content.trimEnd().split(`
+`);
+        let found = false;
+        const updated = lines.map((line) => {
+          const entry = JSON.parse(line);
+          if (entry.task_id === taskId) {
+            found = true;
+            updater(entry);
+          }
+          return JSON.stringify(entry);
+        });
+        if (!found)
+          continue;
+        const tmpPath = join2(timelineDir, `.${filename}.tmp`);
+        writeFileSync(tmpPath, updated.join(`
+`) + `
+`);
+        renameSync(tmpPath, filePath);
+        return;
+      } finally {
+        releaseLock(lockPath);
+      }
+    } catch (err) {
+      log2.debug(`Timeline updateEntry failed for ${filename}`, err);
+    }
+  }
+  log2.debug(`Timeline updateEntry: task_id ${taskId} not found in last 7 days`);
+}
+function createTimelineEntry(taskId, prompt, type, sessionId, pid, provider, contextKey, detailedLog) {
+  return {
+    task_id: taskId,
+    context_key: contextKey ?? null,
+    session_id: sessionId || null,
+    pid: pid ?? null,
+    status: "running",
+    datetime: localISOString(),
+    type,
+    prompt,
+    agent_responses: [],
+    errmsg: null,
+    provider: provider ?? null,
+    detailed_log: detailedLog ?? null
+  };
+}
+var RESUME_MAX_AGE_MS = 72 * 60 * 60 * 1000;
+
+// daemon/meeting-runner.ts
+var log3 = createLogger({ module: "meeting-runner" });
+var SCRAPE_INTERVAL_MS = 3000;
+var DEFAULT_BOT_NAME = "Alook Meeting Bot";
+var MAX_RETRY_DURATION_MS = 30 * 60 * 1000;
+var RETRY_BACKOFF = [30000, 60000, 120000, 300000];
+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
+    });
+    log3.info(`callback ${status} → HTTP ${res.status}`, { meeting: input.meetingId });
+  } catch (err) {
+    log3.error(`callback failed: ${err instanceof Error ? err.message : err}`, { meeting: input.meetingId });
+  }
+}
+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 {
+    const botName = input.agentName ? `${input.agentName} (Alook)` : DEFAULT_BOT_NAME;
+    await joinMeeting(page, input.meetingUrl, botName);
+    log3.info("joined meeting, waiting for UI ready...", { meeting: input.meetingId });
+    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();
+        }
+      }
+    });
+    log3.info("meeting ready, enabling captions...", { meeting: input.meetingId });
+    await enableCaptions(page);
+    await page.evaluate(buildCaptionObserverScript());
+    await page.evaluate(buildAloneDetectorScript());
+    log3.info("captions enabled, scraping loop started", { meeting: input.meetingId });
+    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());
+            log3.debug(`final scrape: ${finalCaptions.length} caption(s), total ${transcript.length}`, { meeting: input.meetingId });
+          }
+          log3.info("meeting ended (no longer active)", { meeting: input.meetingId });
+          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) {
+            log3.debug(`caption: ${captions[captions.length - 1].speaker}: "${captions[captions.length - 1].text}" (total ${transcript.length})`, { meeting: input.meetingId });
+          }
+        } else if (scrapeCount <= 5) {
+          log3.debug(`scrape #${scrapeCount}: no captions yet`, { meeting: input.meetingId });
+        }
+      } catch (err) {
+        log3.error(`scrape error: ${err instanceof Error ? err.message : err}`, { meeting: input.meetingId });
+        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 = join3(tempDir("alook-meetings"), `meeting-${input.meetingId}-blocked.png`);
+      await page.screenshot({ path: screenshotPath }).catch(() => {});
+      log3.warn(`blocked from joining, screenshot saved: ${screenshotPath}`, { meeting: input.meetingId });
+      return { status: "blocked", transcript, error: msg };
+    }
+    log3.error(`unexpected error: ${msg}`, { meeting: input.meetingId });
+    return { status: "error", transcript, error: msg };
+  } finally {
+    await page.close().catch(() => {});
+    await browser.close().catch(() => {});
+  }
+}
+function writeTimeline(input, status, responses, errmsg) {
+  if (!input.timelineDir)
+    return;
+  try {
+    mkdirSync2(input.timelineDir, { recursive: true });
+    const taskId = `meeting-${input.meetingId}`;
+    if (status === "running") {
+      const meetingLabel = input.title || input.meetingUrl;
+      const entry = createTimelineEntry(taskId, `Meeting: ${meetingLabel} (participants: ${input.participants.join(", ")})`, "meeting", undefined, process.pid);
+      initEntry(input.timelineDir, entry);
+    } else {
+      updateEntry(input.timelineDir, taskId, (entry) => {
+        entry.status = status;
+        entry.pid = null;
+        if (responses)
+          entry.agent_responses = responses;
+        if (errmsg)
+          entry.errmsg = errmsg;
+      });
+    }
+  } catch (err) {
+    log3.debug(`timeline write failed: ${err instanceof Error ? err.message : err}`);
+  }
+}
+async function run(input) {
+  log3.info(`starting meeting: url=${input.meetingUrl}`, { meeting: input.meetingId, workspace: input.workspaceId });
+  writeTimeline(input, "running");
+  let chromePath;
+  try {
+    chromePath = ensureChrome();
+    log3.debug(`chrome found: ${chromePath}`);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    log3.error(`chrome setup failed: ${msg}`, { meeting: input.meetingId });
+    writeTimeline(input, "failed", undefined, `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++;
+    log3.info(attempt > 1 ? `retry attempt #${attempt}` : "launching browser (en-US, stealth)...", { meeting: input.meetingId });
+    const result = await tryJoinAndRecord(input, chromePath);
+    if (result.status === "completed") {
+      const transcriptText = formatTranscript(result.transcript);
+      log3.info(`completed: ${result.transcript.length} transcript entries`, { meeting: input.meetingId });
+      const transcriptR2Key = `meetings/${input.meetingId}/transcript`;
+      writeTimeline(input, "completed", [
+        `Meeting completed. ${result.transcript.length} transcript entries captured.`,
+        `Transcript stored at: ${transcriptR2Key}`
+      ]);
+      await callbackWeb(input, "completed", transcriptText);
+      return;
+    }
+    if (result.status === "blocked") {
+      const elapsed = Date.now() - startTime;
+      if (elapsed >= MAX_RETRY_DURATION_MS) {
+        log3.warn(`giving up after ${Math.round(elapsed / 60000)}min of retries`, { meeting: input.meetingId });
+        writeTimeline(input, "failed", undefined, result.error);
+        await callbackWeb(input, "failed", undefined, result.error);
+        return;
+      }
+      const backoff = RETRY_BACKOFF[Math.min(attempt - 1, RETRY_BACKOFF.length - 1)];
+      log3.info(`blocked, retrying in ${backoff / 1000}s (attempt=${attempt}, elapsed=${Math.round(elapsed / 60000)}min)`, { meeting: input.meetingId });
+      await new Promise((resolve) => setTimeout(resolve, backoff));
+      continue;
+    }
+    writeTimeline(input, "failed", undefined, result.error);
+    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) => {
+  log3.error(`fatal: ${err instanceof Error ? err.message : err}`);
+  process.exit(1);
+});