Skip to content
Back to search

open-utter

SkillWorks with Claude CodeGitHub

Headless Google Meet bot that joins meetings and captures live captions as transcripts.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/sumansid--openutter/badge.svg)](/listings/sumansid--openutter)

HTML

<a href="/listings/sumansid--openutter"><img src="/api/listings/sumansid--openutter/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

npx openutter

This installs the OpenUtter skill into:

~/.openclaw/skills/openutter

For example, on a Linux host running OpenClaw as the `openclaw` user, that path would usually be:

/home/openclaw/.openclaw/skills/openutter/

By default, OpenUtter installs into that shared OpenClaw skills directory no matter which folder you run `npx openutter` from.

If you want to install into a specific location instead, use `--target-dir`:

npx openutter --target-dir ./skills/openutter

That is useful if you want a repo-local/workspace-local install instead of the default shared install under `~/.openclaw/skills/openutter`.

During install, OpenUtter also tries to:

- install Chromium via Playwright - verify Chromium can actually launch - auto-install Linux runtime dependencies when supported and running as root

If Linux system dependencies are missing and OpenUtter cannot install them automatically, it prints the exact command to run.

If you ever want to install Chromium manually, you can still run:

npx playwright-core install chromium

At that point, OpenUtter is ready for guest joins. Google account auth is optional and only needed if you want to join with `--auth` instead of waiting in the guest lobby.

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

SKILL.md · Manifest · 233 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. ---
  2. name: open-utter
  3. description: Headless Google Meet bot that joins meetings and captures live captions as transcripts.
  4. homepage: https://github.com/sumansid/openutter
  5. metadata: { "openclaw": { "emoji": "🦦", "requires": { "bins": ["node"] } } }
  6. ---
  7. # OpenUtter
  8. ## STOP — Ask the user before doing anything
  9. **When the user asks to join a meeting, you MUST do these steps IN ORDER. Do NOT skip ahead.**
  10. **Step A:** Read the file `~/.openutter/auth-meta.json` (it may not exist — that's fine).
  11. **Step B:** Ask the user how they want to join. Do NOT launch the bot yet.
  12. If auth-meta.json exists and has an `email` field, ask:
  13. > "How would you like to join the meeting?
  14. > 1. Join as **user@gmail.com** (authenticated — no host approval needed)
  15. > 2. Join as **OpenUtter Bot** (guest — host must admit)
  16. > 3. Join with a custom name (guest)"
  17. If auth-meta.json does NOT exist, ask:
  18. > "What name should the bot use to join the meeting?"
  19. Default to "OpenUtter Bot" if the user doesn't have a preference.
  20. **Step C:** WAIT for the user to answer. Only then launch the bot with the right flags.
  21. - User chose authenticated → use `--auth`
  22. - User chose guest → use `--anon --bot-name "Their Name"` (always ask for a name)
  23. **The bot will refuse to start without `--auth` or `--anon`.
  24. When using `--anon`, `--bot-name` is also required.**
  25. ---
  26. A meeting bot that joins Google Meet meetings via Playwright browser automation
  27. and captures live captions as a real-time transcript.
  28. ## Prerequisites
  29. - `playwright-core` (ships with openclaw)
  30. - Chromium browser: `npx playwright-core install chromium`
  31. ## Join a Meeting
  32. **IMPORTANT: Always run these commands with `background:true`** — the bot is a long-running
  33. process that stays in the meeting. Do not wait for it to complete; background it immediately
  34. and poll for status updates.
  35. ### Launch command
  36. ```bash
  37. exec background:true command:"npx openutter join https://meet.google.com/abc-defg-hij --auth|--anon --channel <current-channel> --target <current-chat-id>"
  38. ```
  39. **IMPORTANT:** Always pass `--channel` and `--target` from the current conversation context.
  40. The bot uses these to send screenshots and status images directly to the user's chat.
  41. Options (required — bot will error without one):
  42. - `--auth` — join using saved Google account (~/.openutter/auth.json)
  43. - `--anon --bot-name "Name"` — join as a guest with this display name (both required together)
  44. Other options:
  45. - `--headed` — show the browser window (for debugging)
  46. - `--camera` — join with camera on (default: off)
  47. - `--mic` — join with microphone on (default: off)
  48. - `--duration 60m` — auto-leave after duration (supports ms/s/m/h)
  49. ## Live Caption Transcript
  50. Captions are automatically captured whenever the bot is in a meeting. After joining,
  51. the bot enables Google Meet's built-in live captions and captures the text via a
  52. MutationObserver. Captions are deduplicated (Meet updates word-by-word) and flushed
  53. to a transcript file every 5 seconds.
  54. **Transcript location:** `~/.openclaw/workspace/openutter/transcripts/<meeting-id>-<YYYY-MM-DD>.txt`
  55. **Format:**
  56. ```
  57. [14:30:05] Alice: Hey everyone, let's get started
  58. [14:30:12] Bob: Sounds good, I have the updates ready
  59. [14:30:25] Alice: Great, go ahead
  60. ```
  61. When the meeting ends, the bot prints `[OPENUTTER_TRANSCRIPT] <path>` with the transcript file path.
  62. ## Get Transcript (what are they saying?)
  63. **When the user asks "what are they saying?", "what's happening?", "summarize the meeting",
  64. or anything about meeting content — run this script. Do NOT use utter-screenshot.ts for this.**
  65. ```bash
  66. exec command:"npx openutter transcript"
  67. ```
  68. Use `--last 20` to get only the last 20 lines (for long meetings).
  69. Read the output and summarize it for the user in natural language.
  70. ## Take a Screenshot (visual context only)
  71. If the user asks to **see** the meeting (e.g. "send me a screenshot", "what does it look like"):
  72. ```bash
  73. exec command:"npx openutter screenshot"
  74. ```
  75. Send the screenshot image to the user via `message`. Do NOT read the screenshot yourself.
  76. ## How It Works
  77. 1. **Join**: Launches headless Chromium, navigates to the Meet URL, enters the bot name, clicks "Ask to join", and waits for the host to admit it.
  78. 2. **Caption capture**: After joining, the bot clicks the CC button to enable Google Meet's live captions, then injects a MutationObserver to capture caption text from the DOM. Captions are deduplicated (partial word-by-word updates are ignored) and flushed to a transcript file every 5 seconds.
  79. ## Authentication (Optional)
  80. By default the bot joins as a guest and needs host admission. To join as an authenticated
  81. Google user (no admission needed), run the auth script once:
  82. ```bash
  83. npx openutter auth
  84. ```
  85. This opens a headed browser — sign into Google, then press Enter. The session is saved to
  86. `~/.openutter/auth.json` and automatically loaded on future joins. Re-run if the session expires.
  87. ## Files
  88. - `~/.openutter/auth.json` — saved Google session (cookies + localStorage, from utter-auth.ts)
  89. - `~/.openutter/chrome-profile/` — persistent Chromium profile (used when no auth.json)
  90. - `~/.openutter/config.json` — bot configuration (optional)
  91. - `~/.openclaw/workspace/openutter/transcripts/` — live caption transcripts
  92. - `~/.openclaw/workspace/openutter/on-demand-screenshot.png` — on-demand screenshot from a running meeting
  93. - `~/.openclaw/workspace/openutter/debug-join-failed.png` — screenshot on join failure
  94. - `~/.openclaw/workspace/openutter/debug-admit-failed.png` — screenshot on admission failure
  95. - `~/.openclaw/workspace/openutter/joined-meeting.png` — confirmation screenshot after joining
  96. ## Headless VM Tips
  97. - Chrome flags `--use-fake-ui-for-media-stream` and `--use-fake-device-for-media-stream` are set automatically, so no real camera/mic hardware is needed.
  98. - No X11/Wayland display is required — runs fully headless.
  99. - Use `--duration` to auto-leave after a set time.
  100. ## Agent Behavior — MANDATORY
  101. After launching the bot with `exec background:true`, you MUST poll the process
  102. to check for success/failure and send screenshots back to the user.
  103. ### Step 1: Poll for output
  104. After starting the background exec, poll the process every 10–15 seconds:
  105. ```
  106. process action:poll
  107. ```
  108. ### Step 2: Parse markers and send images using the message tool
  109. The bot prints machine-readable markers. When you see them, you MUST use the
  110. `message` tool to send the screenshot image to the user.
  111. **On success** — bot prints `[OPENUTTER_SUCCESS_IMAGE] <path>`:
  112. ```
  113. message action:"send" media:"./openutter/joined-meeting.png" content:"Successfully joined the meeting!"
  114. ```
  115. **On screenshot request** — bot prints `[OPENUTTER_SCREENSHOT] <path>`:
  116. ```
  117. message action:"send" media:"./openutter/on-demand-screenshot.png" content:"Here's the current meeting view"
  118. ```
  119. **On failure** — bot prints `[OPENUTTER_DEBUG_IMAGE] <path>` (or exits non-zero):
  120. ```
  121. message action:"send" media:"./openutter/debug-join-failed.png" content:"Could not join the meeting. Here is what the bot saw"
  122. ```
  123. **CRITICAL: ALWAYS use the `message` tool with `media:"./openutter/<filename>.png"` to send screenshots.**
  124. Use relative paths only (starting with `./`). Never use absolute paths or ~ paths.
  125. NEVER just describe what happened in text. The user MUST receive the actual image.
  126. **When the user asks "send me screenshot" or "what do you see"**, run
  127. `utter-screenshot.ts`, then use the `message` tool with `media:"./openutter/on-demand-screenshot.png"`.
  128. ### Step 3: When user asks about meeting content
  129. **CRITICAL: When the user asks what's happening, what someone said, or anything about
  130. meeting content — run `utter-transcript.ts`. NEVER use `utter-screenshot.ts` for this.**
  131. ```bash
  132. exec command:"npx openutter transcript"
  133. ```
  134. Read the output and summarize it for the user. Use `--last 20` for long meetings.
  135. **On meeting end** — bot prints `[OPENUTTER_TRANSCRIPT] <path>`:
  136. Run `utter-transcript.ts` and provide a summary to the user.
  137. ### When to use which script
  138. | User asks... | Use this script |
  139. |-------------------------------------------|--------------------------|
  140. | "what are they saying?" | `utter-transcript.ts` |
  141. | "what's happening in the meeting?" | `utter-transcript.ts` |
  142. | "summarize the meeting" | `utter-transcript.ts` |
  143. | "what did they talk about?" | `utter-transcript.ts` |
  144. | "send me a screenshot" | `utter-screenshot.ts` |
  145. | "what does the meeting look like?" | `utter-screenshot.ts` |
  146. **NEVER read or analyze screenshot images to understand meeting content.**
  147. ### Screenshot files
  148. - `~/.openclaw/workspace/openutter/joined-meeting.png` — confirmation screenshot after joining
  149. - `~/.openclaw/workspace/openutter/debug-join-failed.png` — join button not found
  150. - `~/.openclaw/workspace/openutter/debug-admit-failed.png` — not admitted / blocked / timed out
  151. ## Troubleshooting
  152. - **Join button not found**: Google Meet UI changes occasionally. The debug screenshot shows what the bot saw — send it to the user.
  153. - **Not admitted**: The bot joins as a guest and needs host approval. Ask the host to admit "OpenUtter Bot". If timed out, the debug screenshot is sent automatically.
  154. - **No captions captured**: The CC button selector may change with Meet updates. If the transcript is empty, captions may not have been enabled. Try `--headed` to verify the CC button is clicked.
  155. - **Headless blocked**: The bot uses stealth patches to bypass headless detection. If Google Meet blocks it, try `--headed` for debugging.
README.md · README · 213 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. # OpenUtter - [Demo](https://x.com/0xSuman/status/2028365808733397180?s=20)
  2. <img width="1376" height="768" alt="Generated Image March 01, 2026 - 2_20PM (1)" src="https://github.com/user-attachments/assets/ce352f31-d381-450d-af6a-a01e57b13d6d" />
  3. OpenUtter is a headless Google Meet bot for OpenClaw. It can join meetings,
  4. capture live captions into a transcript, and take on-demand screenshots.
  5. GitHub: https://github.com/sumansid/openutter
  6. ## Install
  7. ```bash
  8. npx openutter
  9. ```
  10. This installs the OpenUtter skill into:
  11. ```bash
  12. ~/.openclaw/skills/openutter
  13. ```
  14. For example, on a Linux host running OpenClaw as the `openclaw` user, that path
  15. would usually be:
  16. ```bash
  17. /home/openclaw/.openclaw/skills/openutter/
  18. ```
  19. By default, OpenUtter installs into that shared OpenClaw skills directory no
  20. matter which folder you run `npx openutter` from.
  21. If you want to install into a specific location instead, use `--target-dir`:
  22. ```bash
  23. npx openutter --target-dir ./skills/openutter
  24. ```
  25. That is useful if you want a repo-local/workspace-local install instead of the
  26. default shared install under `~/.openclaw/skills/openutter`.
  27. During install, OpenUtter also tries to:
  28. - install Chromium via Playwright
  29. - verify Chromium can actually launch
  30. - auto-install Linux runtime dependencies when supported and running as root
  31. If Linux system dependencies are missing and OpenUtter cannot install them
  32. automatically, it prints the exact command to run.
  33. If you ever want to install Chromium manually, you can still run:
  34. ```bash
  35. npx playwright-core install chromium
  36. ```
  37. At that point, OpenUtter is ready for guest joins. Google account auth is
  38. optional and only needed if you want to join with `--auth` instead of waiting
  39. in the guest lobby.
  40. ## Commands
  41. ```bash
  42. npx openutter join <meet-url> --anon --bot-name "OpenUtter Bot"
  43. npx openutter join <meet-url> --auth
  44. npx openutter join <meet-url> --auth --headed
  45. npx openutter auth
  46. npx openutter transcript
  47. npx openutter transcript --last 20
  48. npx openutter screenshot
  49. ```
  50. ## What It Does
  51. 1. Joins a Google Meet call as a guest or authenticated user.
  52. 2. Enables Google Meet live captions.
  53. 3. Captures captions in real time via DOM observation.
  54. 4. Writes a deduplicated transcript to disk.
  55. 5. Supports on-demand screenshots.
  56. ## Authenticate Once (Optional)
  57. Authentication is optional.
  58. By default, OpenUtter can join as a guest with:
  59. ```bash
  60. npx openutter join <meet-url> --anon --bot-name "Your Bot Name"
  61. ```
  62. Guest mode works, and OpenUtter retries the join flow up to 3 times when Meet
  63. blocks or drops the request. But authentication is the best way to make sure
  64. the bot gets admitted reliably, because it joins as your signed-in Google
  65. account with `--auth` instead of waiting in the guest lobby for host approval.
  66. To save a Google session for authenticated joins:
  67. ```bash
  68. npx openutter auth
  69. ```
  70. This opens a browser window. Sign in to Google, then press Enter in the
  71. terminal. Your session is saved to:
  72. ```bash
  73. ~/.openutter/auth.json
  74. ```
  75. After that, you can join with:
  76. ```bash
  77. npx openutter join <meet-url> --auth
  78. ```
  79. ## Join a Meeting
  80. Guest mode:
  81. ```bash
  82. npx openutter join https://meet.google.com/abc-defg-hij --anon --bot-name "My Bot"
  83. ```
  84. Authenticated mode:
  85. ```bash
  86. npx openutter join https://meet.google.com/abc-defg-hij --auth
  87. ```
  88. Headed mode for debugging:
  89. ```bash
  90. npx openutter join https://meet.google.com/abc-defg-hij --auth --headed
  91. ```
  92. This opens the Chromium window instead of running fully headless, which is
  93. useful if you need to debug login, admission, or caption issues.
  94. Common options:
  95. - `--headed` shows the browser for debugging
  96. - `--duration 30m` auto-leaves after a duration
  97. - `--channel <channel>` sends status updates through OpenClaw
  98. - `--target <id>` sets the target chat for those updates
  99. - `--verbose` prints live caption activity
  100. ## Transcript
  101. Read the latest transcript:
  102. ```bash
  103. npx openutter transcript
  104. ```
  105. Read only the latest lines:
  106. ```bash
  107. npx openutter transcript --last 20
  108. ```
  109. Transcripts are saved under:
  110. ```bash
  111. ~/.openclaw/workspace/openutter/transcripts/<meeting-id>.txt
  112. ```
  113. OpenUtter uses the Google Meet meeting ID as the transcript filename. For
  114. example, joining `https://meet.google.com/abc-defg-hij` saves captions to:
  115. ```bash
  116. ~/.openclaw/workspace/openutter/transcripts/abc-defg-hij.txt
  117. ```
  118. Example format:
  119. ```text
  120. [14:30:05] Alice: Hey everyone, let's get started
  121. [14:30:12] Bob: Sounds good, I have the updates ready
  122. [14:30:25] Alice: Great, go ahead
  123. ```
  124. ## Screenshot
  125. Request an on-demand screenshot from a running meeting:
  126. ```bash
  127. npx openutter screenshot
  128. ```
  129. ## Files
  130. - `~/.openutter/auth.json` saved Google session
  131. - `~/.openutter/auth-meta.json` saved login metadata
  132. - `~/.openutter/chrome-profile/` persistent Chromium profile
  133. - `~/.openclaw/workspace/openutter/transcripts/` transcript output
  134. - `~/.openclaw/workspace/openutter/on-demand-screenshot.png` screenshot output
  135. - `~/.openclaw/workspace/openutter/debug-join-failed.png` join failure screenshot
  136. - `~/.openclaw/workspace/openutter/debug-admit-failed.png` admit failure screenshot
  137. ## Troubleshooting
  138. - If Chromium is missing, run `npx playwright-core install chromium`.
  139. - If guest join is stuck, ask the host to admit your bot by name.
  140. - If captions are empty, retry with `--headed --verbose` to verify captions were enabled.
  141. - If your Google session expires, run `npx openutter auth` again.
  142. ## Release
  143. This repo can publish directly to npm from GitHub Actions.
  144. 1. Bump `package.json` to the new version.
  145. 2. Commit and push to `main`.
  146. 3. Create and push a matching tag like `v0.1.1`.
  147. 4. GitHub Actions publishes that exact version to npm.
  148. The workflow validates that the git tag matches `package.json`.

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.