openbuilder 0.1.0

package/bin/openbuilder.mjs

@@ -0,0 +1,290 @@
+#!/usr/bin/env node
+
+/**
+ * openbuilder — CLI entry point
+ *
+ * Open-source AI meeting assistant. Join Google Meet meetings,
+ * capture transcripts, and generate AI-powered meeting reports.
+ */
+
+import { spawnSync } from "node:child_process";
+import { createRequire } from "node:module";
+import { cpSync, existsSync, mkdirSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { homedir } from "node:os";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const pkgRoot = resolve(__dirname, "..");
+const skillTargetDirDefault = join(homedir(), ".openclaw", "skills", "openbuilder");
+const require = createRequire(import.meta.url);
+const npxBin = process.platform === "win32" ? "npx.cmd" : "npx";
+
+function printHelp() {
+  console.log(`OpenBuilder — AI Meeting Assistant
+
+Usage:
+  npx openbuilder                                  Install skill + Chromium
+  npx openbuilder install                          Install skill + Chromium
+  npx openbuilder join <meet-url> [options]         Join a Google Meet
+  npx openbuilder auth                              Save Google session
+  npx openbuilder transcript [--last N]             Print latest transcript
+  npx openbuilder screenshot                        Request on-demand screenshot
+  npx openbuilder summarize [transcript-path]       AI summary of a transcript
+  npx openbuilder report [transcript-path]          Full AI meeting report
+  npx openbuilder config [set|get|delete] [...]     Manage configuration
+  npx openbuilder help                              Show this help
+
+Join options:
+  --auth          Join using saved Google account (~/.openbuilder/auth.json)
+  --anon          Join as a guest (requires --bot-name)
+  --bot-name      Guest display name (required with --anon)
+  --duration      Auto-leave after duration (e.g. 30m, 1h)
+  --audio         Force audio capture mode (PulseAudio + Whisper)
+  --captions      Force caption scraping mode (DOM-based fallback)
+  --headed        Show browser window for debugging
+  --camera        Join with camera on (default: off)
+  --mic           Join with microphone on (default: off)
+  --no-report     Skip auto-report generation after meeting ends
+  --verbose       Show real-time transcript output
+  --channel       OpenClaw channel for sending status messages
+  --target        OpenClaw target for sending status messages
+
+  By default, capture mode is "auto": uses audio capture if PulseAudio,
+  ffmpeg, and OPENAI_API_KEY are available, otherwise falls back to captions.
+
+Config:
+  openbuilder config                    Show all settings
+  openbuilder config set <key> <value>  Set a value
+  openbuilder config get <key>          Get a value
+  openbuilder config delete <key>       Remove a value
+
+  Keys: aiProvider, anthropicApiKey, openaiApiKey, botName, defaultDuration,
+        captureMode, whisperModel
+  Env:  OPENBUILDER_AI_PROVIDER, ANTHROPIC_API_KEY, OPENAI_API_KEY,
+        OPENBUILDER_BOT_NAME, OPENBUILDER_DEFAULT_DURATION,
+        OPENBUILDER_CAPTURE_MODE, OPENBUILDER_WHISPER_MODEL
+
+Examples:
+  npx openbuilder join https://meet.google.com/abc-defg-hij --anon --bot-name "Meeting Bot"
+  npx openbuilder join https://meet.google.com/abc-defg-hij --auth --duration 60m
+  npx openbuilder join https://meet.google.com/abc-defg-hij --auth --audio
+  npx openbuilder summarize ~/transcript.txt
+  npx openbuilder report ~/transcript.txt
+  npx openbuilder config set openaiApiKey sk-...
+  npx openbuilder config set captureMode audio`);
+}
+
+function resolveInstallTarget(rawArgs) {
+  const idx = rawArgs.indexOf("--target-dir");
+  if (idx >= 0) {
+    const value = rawArgs[idx + 1];
+    if (!value) {
+      console.error("Missing value for --target-dir");
+      process.exit(1);
+    }
+    return resolve(value);
+  }
+  return skillTargetDirDefault;
+}
+
+function stripInstallFlags(rawArgs) {
+  const next = [];
+  for (let i = 0; i < rawArgs.length; i++) {
+    if (rawArgs[i] === "--target-dir") {
+      i += 1;
+      continue;
+    }
+    next.push(rawArgs[i]);
+  }
+  return next;
+}
+
+function checkOpenClaw() {
+  const result = spawnSync("openclaw", ["--version"], { stdio: "ignore" });
+  return result.status === 0;
+}
+
+function runNodeCommand(args, opts = {}) {
+  const result = spawnSync(process.execPath, args, {
+    stdio: "inherit",
+    cwd: pkgRoot,
+    ...opts,
+  });
+
+  if (result.error) {
+    throw result.error;
+  }
+
+  return result.status ?? 1;
+}
+
+function runPlaywrightCommand(args) {
+  try {
+    const playwrightPackageJson = require.resolve("playwright-core/package.json");
+    const playwrightCliPath = join(dirname(playwrightPackageJson), "cli.js");
+    return runNodeCommand([playwrightCliPath, ...args]);
+  } catch {
+    const result = spawnSync(npxBin, ["-y", "playwright-core", ...args], {
+      stdio: "inherit",
+      cwd: pkgRoot,
+    });
+
+    if (result.error) {
+      throw result.error;
+    }
+
+    return result.status ?? 1;
+  }
+}
+
+function verifyChromiumLaunch() {
+  const script = `
+    import { chromium } from "playwright-core";
+    const browser = await chromium.launch({ headless: true });
+    await browser.close();
+    console.log("Chromium launch check passed.");
+  `;
+
+  return spawnSync(process.execPath, ["--input-type=module", "-e", script], {
+    cwd: pkgRoot,
+    encoding: "utf8",
+  });
+}
+
+function isLinuxRoot() {
+  return process.platform === "linux" && typeof process.getuid === "function" && process.getuid() === 0;
+}
+
+function isMissingLinuxRuntimeLib(stderr = "", stdout = "") {
+  const output = `${stdout}\n${stderr}`;
+  return /error while loading shared libraries|libnspr4\.so|libnss3\.so|libatk-bridge|libxkbcommon|libgbm|libgtk-3/i.test(
+    output,
+  );
+}
+
+function ensureChromiumReady() {
+  console.log("Installing Chromium via Playwright...");
+  const installCode = runPlaywrightCommand(["install", "chromium"]);
+  if (installCode !== 0) {
+    console.error("Failed to install Chromium.");
+    process.exit(installCode);
+  }
+
+  let launchCheck = verifyChromiumLaunch();
+  if (launchCheck.status === 0) {
+    console.log("Chromium is ready.");
+    return;
+  }
+
+  if (isMissingLinuxRuntimeLib(launchCheck.stderr, launchCheck.stdout) && process.platform === "linux") {
+    console.log("Chromium is installed, but Linux runtime libraries are missing.");
+
+    if (isLinuxRoot()) {
+      console.log("Attempting to install Chromium system dependencies...");
+      const depsCode = runPlaywrightCommand(["install-deps", "chromium"]);
+      if (depsCode !== 0) {
+        console.error("Failed to install Linux Chromium dependencies automatically.");
+        process.exit(depsCode);
+      }
+
+      launchCheck = verifyChromiumLaunch();
+      if (launchCheck.status === 0) {
+        console.log("Chromium system dependencies installed successfully.");
+        return;
+      }
+    } else {
+      console.error("Linux Chromium dependencies are missing and this installer is not running as root.");
+      console.error("Run one of these commands, then retry:");
+      console.error("  sudo npx playwright-core install-deps chromium");
+      console.error(
+        "  sudo apt-get update && sudo apt-get install -y libnspr4 libnss3 libatk-bridge2.0-0 libxkbcommon0 libxcomposite1 libxcursor1 libxdamage1 libxi6 libxtst6 libcups2 libdrm2 libgbm1 libgtk-3-0 libpango-1.0-0 libpangocairo-1.0-0 libasound2",
+      );
+      process.exit(1);
+    }
+  }
+
+  console.error("Chromium launch check failed.");
+  if (launchCheck.stderr?.trim()) {
+    console.error(launchCheck.stderr.trim());
+  } else if (launchCheck.stdout?.trim()) {
+    console.error(launchCheck.stdout.trim());
+  }
+  process.exit(1);
+}
+
+function installSkill(targetDir) {
+  mkdirSync(targetDir, { recursive: true });
+  cpSync(join(pkgRoot, "SKILL.md"), join(targetDir, "SKILL.md"));
+  cpSync(join(pkgRoot, "scripts"), join(targetDir, "scripts"), { recursive: true });
+
+  // Also copy src directory (needed by scripts)
+  if (existsSync(join(pkgRoot, "src"))) {
+    cpSync(join(pkgRoot, "src"), join(targetDir, "src"), { recursive: true });
+  }
+
+  ensureChromiumReady();
+
+  console.log(`\nInstalled OpenBuilder to ${targetDir}`);
+  if (!checkOpenClaw()) {
+    console.log("Warning: `openclaw` was not found in PATH. Install OpenClaw before using the skill.");
+  }
+  console.log("Start a new OpenClaw session to pick it up.");
+  console.log("\nOptional setup:");
+  console.log("  npx openbuilder auth                          — Sign in for authenticated joins");
+  console.log("  npx openbuilder config set anthropicApiKey ... — Enable AI reports");
+}
+
+function runScript(scriptName, args) {
+  const scriptPath = join(pkgRoot, "scripts", scriptName);
+  if (!existsSync(scriptPath)) {
+    console.error(`Missing script: ${scriptPath}`);
+    process.exit(1);
+  }
+
+  const result = spawnSync(process.execPath, ["--import", "tsx", scriptPath, ...args], {
+    stdio: "inherit",
+  });
+
+  if (result.error) {
+    console.error(result.error.message);
+    process.exit(1);
+  }
+
+  process.exit(result.status ?? 0);
+}
+
+// ── Main CLI routing ───────────────────────────────────────────────────
+
+const rawArgs = process.argv.slice(2);
+const command = rawArgs[0];
+
+if (!command || command === "install") {
+  installSkill(resolveInstallTarget(rawArgs));
+} else if (command === "auth") {
+  runScript("builder-auth.ts", rawArgs.slice(1));
+} else if (command === "join") {
+  runScript("builder-join.ts", rawArgs.slice(1));
+} else if (command === "transcript") {
+  runScript("builder-transcript.ts", rawArgs.slice(1));
+} else if (command === "screenshot") {
+  runScript("builder-screenshot.ts", rawArgs.slice(1));
+} else if (command === "summarize") {
+  runScript("builder-summarize.ts", rawArgs.slice(1));
+} else if (command === "report") {
+  runScript("builder-report.ts", rawArgs.slice(1));
+} else if (command === "config") {
+  runScript("builder-config.ts", rawArgs.slice(1));
+} else if (command === "help" || command === "--help" || command === "-h") {
+  printHelp();
+} else {
+  const remaining = stripInstallFlags(rawArgs);
+  if (remaining.length === 0) {
+    installSkill(resolveInstallTarget(rawArgs));
+  } else {
+    console.error(`Unknown command: ${command}`);
+    console.log("");
+    printHelp();
+    process.exit(1);
+  }
+}

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "openbuilder",
+  "version": "0.1.0",
+  "description": "Open-source AI meeting assistant — join Google Meet, capture transcripts, generate AI-powered meeting reports with summaries, action items, and speaker analytics",
+  "type": "module",
+  "bin": {
+    "openbuilder": "bin/openbuilder.mjs"
+  },
+  "files": [
+    "bin",
+    "scripts",
+    "src",
+    "SKILL.md"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/superliangbot/openbuilder.git"
+  },
+  "homepage": "https://github.com/superliangbot/openbuilder",
+  "license": "MIT",
+  "engines": {
+    "node": ">=18"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@anthropic-ai/sdk": "^0.78.0",
+    "dotenv": "^17.3.1",
+    "playwright-core": "^1.58.2",
+    "tsx": "^4.21.0"
+  },
+  "peerDependencies": {
+    "openai": "^6.27.0"
+  },
+  "peerDependenciesMeta": {
+    "@anthropic-ai/sdk": {
+      "optional": true
+    },
+    "openai": {
+      "optional": true
+    }
+  },
+  "keywords": [
+    "meeting",
+    "assistant",
+    "ai",
+    "google-meet",
+    "transcript",
+    "summary",
+    "action-items",
+    "meeting-notes",
+    "openclaw"
+  ]
+}

package/scripts/builder-auth.ts

@@ -0,0 +1,265 @@
+#!/usr/bin/env npx tsx
+/**
+ * builder-auth.ts — Automated Google sign-in via Playwright
+ *
+ * Usage:
+ *   npx openbuilder auth              # Interactive (headed browser)
+ *   npx openbuilder auth --auto       # Automated using GOOGLE_EMAIL + GOOGLE_PASSWORD from .env
+ *
+ * Saves session to ~/.openbuilder/auth.json via Playwright's storageState.
+ */
+
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { createInterface } from "node:readline";
+import { config as dotenvConfig } from "dotenv";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+import {
+  AUTH_FILE,
+  AUTH_META_FILE,
+  OPENBUILDER_DIR,
+} from "../src/utils/config.js";
+
+// Load .env from project root
+const __dirname2 = dirname(fileURLToPath(import.meta.url));
+dotenvConfig({ path: join(__dirname2, "..", ".env") });
+
+type PlaywrightMod = typeof import("playwright-core");
+type Page = import("playwright-core").Page;
+
+async function waitForEnter(prompt: string): Promise<void> {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve) => {
+    rl.question(prompt, () => {
+      rl.close();
+      resolve();
+    });
+  });
+}
+
+async function sleep(ms: number) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+
+async function autoSignIn(page: Page, email: string, password: string): Promise<boolean> {
+  console.log("Navigating to Google sign-in...");
+  await page.goto("https://accounts.google.com/signin", { waitUntil: "domcontentloaded" });
+  await sleep(2000);
+
+  // Screenshot for debugging
+  const ssDir = join(OPENBUILDER_DIR, "auth-debug");
+  mkdirSync(ssDir, { recursive: true });
+
+  // Enter email
+  console.log("Entering email...");
+  const emailInput = page.locator('input[type="email"]');
+  await emailInput.waitFor({ state: "visible", timeout: 15000 });
+  await emailInput.fill(email);
+  await sleep(500);
+
+  // Click Next
+  const nextBtn = page.locator('#identifierNext button, button:has-text("Next")').first();
+  await nextBtn.click();
+  await sleep(3000);
+
+  await page.screenshot({ path: join(ssDir, "after-email.png") });
+
+  // Check for CAPTCHA or challenge
+  const pageText = await page.textContent("body").catch(() => "");
+  if (pageText?.includes("Verify it's you") || pageText?.includes("confirm your identity")) {
+    console.error("\n⚠️  Google is requesting additional verification (CAPTCHA/challenge).");
+    console.error("You may need to run `npx openbuilder auth` interactively (without --auto).");
+    await page.screenshot({ path: join(ssDir, "challenge.png") });
+    return false;
+  }
+
+  // Enter password
+  console.log("Entering password...");
+  const passwordInput = page.locator('input[type="password"]');
+  try {
+    await passwordInput.waitFor({ state: "visible", timeout: 10000 });
+  } catch {
+    console.error("Password field not found. Google may be showing a challenge.");
+    await page.screenshot({ path: join(ssDir, "no-password-field.png") });
+    return false;
+  }
+  await passwordInput.fill(password);
+  await sleep(500);
+
+  // Click Next for password
+  const passNext = page.locator('#passwordNext button, button:has-text("Next")').first();
+  await passNext.click();
+  await sleep(5000);
+
+  await page.screenshot({ path: join(ssDir, "after-password.png") });
+
+  // Check if we landed on myaccount or got challenged
+  const url = page.url();
+  const bodyText = await page.textContent("body").catch(() => "");
+
+  if (url.includes("myaccount.google.com") || url.includes("accounts.google.com/signin/v2/challenge") === false) {
+    // Try navigating to myaccount to confirm
+    await page.goto("https://myaccount.google.com", { waitUntil: "domcontentloaded", timeout: 15000 });
+    await sleep(2000);
+    await page.screenshot({ path: join(ssDir, "myaccount.png") });
+
+    const finalUrl = page.url();
+    if (finalUrl.includes("myaccount.google.com") && !finalUrl.includes("signin")) {
+      console.log("✅ Sign-in successful!");
+      return true;
+    }
+  }
+
+  // Check for 2FA
+  if (bodyText?.includes("2-Step Verification") || bodyText?.includes("Verify it")) {
+    console.error("\n⚠️  2-Step Verification required.");
+    console.error("Either disable 2FA on this account or use interactive mode.");
+    await page.screenshot({ path: join(ssDir, "2fa.png") });
+    return false;
+  }
+
+  // Check for wrong password
+  if (bodyText?.includes("Wrong password") || bodyText?.includes("Couldn't sign you in")) {
+    console.error("\n❌ Wrong password or sign-in rejected.");
+    await page.screenshot({ path: join(ssDir, "wrong-password.png") });
+    return false;
+  }
+
+  // Might have succeeded anyway — try to save
+  console.log("Sign-in status unclear, attempting to save session...");
+  await page.screenshot({ path: join(ssDir, "unclear.png") });
+  return true;
+}
+
+async function main() {
+  mkdirSync(OPENBUILDER_DIR, { recursive: true });
+
+  const args = process.argv.slice(2);
+  const autoMode = args.includes("--auto");
+  const headed = args.includes("--headed") || !autoMode; // Auto mode can run headless
+
+  let pw: PlaywrightMod;
+  try {
+    pw = await import("playwright-core");
+  } catch {
+    console.error("playwright-core not found. Run `npm install`.");
+    process.exit(1);
+  }
+
+  console.log("OpenBuilder — Google Account Login\n");
+
+  if (existsSync(AUTH_FILE)) {
+    console.log(`Existing auth found at ${AUTH_FILE}`);
+    console.log("This will overwrite it with a new session.\n");
+  }
+
+  // For auto mode on headless server, use Xvfb
+  const headless = !headed;
+  const chromiumArgs = [
+    "--disable-blink-features=AutomationControlled",
+    "--no-first-run",
+    "--no-default-browser-check",
+    "--window-size=1280,720",
+  ];
+
+  // Find full Chrome for headed mode
+  let executablePath: string | undefined;
+  const fullChromePath = join(
+    process.env.HOME || "~",
+    ".cache/ms-playwright/chromium-1208/chrome-linux64/chrome"
+  );
+  if (existsSync(fullChromePath)) {
+    executablePath = fullChromePath;
+  }
+
+  const browser = await pw.chromium.launch({
+    headless,
+    executablePath,
+    args: chromiumArgs,
+    ignoreDefaultArgs: ["--enable-automation"],
+  });
+
+  const context = await browser.newContext({
+    viewport: { width: 1280, height: 720 },
+    userAgent:
+      "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36",
+  });
+
+  const page = await context.newPage();
+  let email = "unknown";
+
+  if (autoMode) {
+    const gEmail = process.env.GOOGLE_EMAIL;
+    const gPassword = process.env.GOOGLE_PASSWORD;
+
+    if (!gEmail || !gPassword) {
+      console.error("--auto requires GOOGLE_EMAIL and GOOGLE_PASSWORD in .env");
+      await browser.close();
+      process.exit(1);
+    }
+
+    console.log(`Attempting automated sign-in for ${gEmail}...\n`);
+    const success = await autoSignIn(page, gEmail, gPassword);
+
+    if (!success) {
+      console.error("\nAutomated sign-in failed. Check screenshots in ~/.openbuilder/auth-debug/");
+      await browser.close();
+      process.exit(1);
+    }
+
+    email = gEmail;
+  } else {
+    // Interactive mode
+    await page.goto("https://accounts.google.com", { waitUntil: "domcontentloaded" });
+    console.log("Browser opened — sign into Google now.\n");
+    await waitForEnter("Press Enter after you've signed in to Google... ");
+
+    // Extract email
+    try {
+      await page.goto("https://myaccount.google.com", { waitUntil: "domcontentloaded", timeout: 10000 });
+      await sleep(2000);
+      email = await page.evaluate(() => {
+        const emailEl = document.querySelector("[data-email]");
+        if (emailEl) return emailEl.getAttribute("data-email") || "";
+        const profileBtn = document.querySelector('[aria-label*="@"]');
+        if (profileBtn) {
+          const match = profileBtn.getAttribute("aria-label")?.match(/[\w.+-]+@[\w-]+\.[\w.]+/);
+          if (match) return match[0];
+        }
+        return "";
+      });
+    } catch { /* not critical */ }
+  }
+
+  if (email && email !== "unknown") {
+    console.log(`\nSigned in as: ${email}`);
+  }
+
+  // Save session
+  await context.storageState({ path: AUTH_FILE });
+  console.log(`Session saved to ${AUTH_FILE}`);
+
+  const meta = { email: email || "unknown", savedAt: new Date().toISOString() };
+  writeFileSync(AUTH_META_FILE, JSON.stringify(meta, null, 2));
+
+  try {
+    const state = JSON.parse(readFileSync(AUTH_FILE, "utf-8"));
+    const cookieCount = state.cookies?.length ?? 0;
+    const originCount = state.origins?.length ?? 0;
+    console.log(`  ${cookieCount} cookies, ${originCount} origins saved`);
+  } catch { /* not critical */ }
+
+  await browser.close();
+
+  console.log("\nDone! The bot will now join meetings as an authenticated user.");
+  console.log("Run: npx openbuilder join <meet-url> --auth");
+}
+
+const isMain = process.argv[1]?.endsWith("builder-auth.ts");
+if (isMain) {
+  main().catch((err) => {
+    console.error("Fatal:", err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  });
+}