@mseep/open-computer-use 1.0.0

package/skills/public/pdf-reading/SKILL.md

@@ -0,0 +1,305 @@
+---
+name: pdf-reading
+description: "Use this skill when you need to read, inspect, or extract content from PDF files — especially when file content is NOT in your context and you need to read it from disk. Covers content inventory, text extraction, page rasterization for visual inspection, embedded image/attachment/table/form-field extraction, and choosing the right reading strategy for different document types (text-heavy, scanned, slide-decks, forms, data-heavy). Do NOT use this skill for PDF creation, form filling, merging, splitting, watermarking, or encryption — use the pdf skill instead."
+license: Proprietary. LICENSE.txt has complete terms
+---
+
+# PDF Processing Guide
+
+## Overview
+
+This guide covers essential PDF reading operations using Python libraries and command-line tools. For advanced features (pypdfium2 rendering, pdfplumber table settings, OCR fallback, encrypted/corrupted PDF handling), see REFERENCE.md.
+
+## Reading & Inspecting PDFs
+
+Before doing anything with a PDF, understand what you're working with.
+
+### Content inventory
+
+Run a quick diagnostic first. For simple tasks ("summarize this
+document"), `pdfinfo` + a text sample may suffice. For anything
+involving figures, attachments, or extraction issues, run the full set:
+
+```bash
+# Always: page count, file size, PDF version, metadata
+pdfinfo document.pdf
+
+# Always: quick text extraction check — is this a text PDF or a scan?
+pdftotext -f 1 -l 1 document.pdf - | head -20
+
+# If figures/charts may matter:
+pdfimages -list document.pdf
+
+# If the PDF might contain embedded files (reports, portfolios):
+pdfdetach -list document.pdf
+
+# If text extraction looks garbled:
+pdffonts document.pdf
+```
+
+This tells you:
+- **Page count and size** — how big is the job?
+- **Text extractability** — does `pdftotext` return real text, or is
+  it empty (scanned) or garbled (broken font encoding)?
+- **Embedded raster images** — are there photos or raster figures?
+  (Note: vector-drawn charts from matplotlib/Excel won't appear — see
+  "Extracting embedded images" below)
+- **Attachments** — are there embedded spreadsheets, data files, etc.?
+- **Font status** — are fonts embedded? If not, text extraction may
+  produce wrong characters.
+
+### Text extraction
+
+**pypdf** for basic text:
+```python
+from pypdf import PdfReader
+
+reader = PdfReader("document.pdf")
+print(f"Pages: {len(reader.pages)}")
+
+# Extract text
+text = ""
+for page in reader.pages:
+    text += page.extract_text()
+```
+
+**pdftotext** preserving layout (better for multi-column docs):
+```bash
+# Layout mode preserves spatial positioning
+pdftotext -layout document.pdf output.txt
+
+# Specific page range
+pdftotext -f 1 -l 5 document.pdf output.txt
+```
+
+**pdfplumber** for layout-aware extraction with positioning data:
+```python
+import pdfplumber
+
+with pdfplumber.open("document.pdf") as pdf:
+    for page in pdf.pages:
+        text = page.extract_text()
+        print(text)
+```
+
+### Visual inspection (rasterize pages)
+
+Text extraction is **blind** to charts, diagrams, figures, equations,
+multi-column layout, and form structures. When any of these matter,
+rasterize the relevant page and Read the image:
+
+```bash
+# Rasterize a single page (page 3 here) at 150 DPI
+pdftoppm -jpeg -r 150 -f 3 -l 3 document.pdf /tmp/page
+
+# pdftoppm zero-pads the output filename based on TOTAL page count
+# (e.g., page-03.jpg for a 50-page PDF, page-003.jpg for 200+ pages)
+# Don't guess the filename — find it:
+ls /tmp/page-*.jpg
+```
+
+Then Read the resulting image file. This gives you full visual
+understanding of that page — layout, charts, equations, everything.
+
+**When to rasterize vs. text-extract:**
+- **Content/data questions → text extraction** (cheaper, searchable)
+- **Figures, charts, visual layout → rasterize the page**
+- **Tables → try text extraction first, rasterize if garbled**
+- **Precision matters → do both** (extract text AND rasterize; use text
+  for data, image for context — this is what Claude's API does natively
+  with PDF uploads)
+
+**Token cost awareness:**
+- Text extraction: ~200–400 tokens per page
+- Rasterized image: ~1,600 tokens per page (at 150 DPI)
+- Both together: ~2,000–2,400 tokens per page
+
+For a 100-page PDF, rasterizing everything would consume ~160K tokens.
+Only rasterize pages that matter for the question at hand.
+
+### Choosing your reading strategy
+
+**Text-heavy documents** (reports, articles, books):
+→ Text extraction is primary. Rasterize only for specific figures or
+  pages where layout matters.
+
+**Scanned documents** (no extractable text):
+→ Rasterize pages at 150 DPI and Read them visually. For bulk text
+  extraction, use OCR (pytesseract after converting pages to images —
+  see REFERENCE.md for a complete example).
+
+**Slide-deck PDFs** (exported presentations):
+→ Every page is primarily visual. Rasterize individual pages on demand.
+  Text extraction gives you bullet-point text but loses all layout.
+
+**Form-heavy documents**:
+→ Extract form field values programmatically first (see below). Rasterize
+  the form page for visual context if needed.
+
+**Data-heavy documents** (tables, charts, figures):
+→ Use pdfplumber for tables. Rasterize pages with charts/figures.
+  Extract text for surrounding narrative. Consider both text AND image
+  for the same page when precision matters.
+
+### Extracting embedded images
+
+```bash
+# List all embedded images with metadata (size, color, compression)
+pdfimages -list document.pdf
+
+# Extract all images as PNG
+pdfimages -png document.pdf /tmp/img
+
+# Extract from specific pages only (pages 3-5)
+pdfimages -png -f 3 -l 5 document.pdf /tmp/img
+
+# Extract in original format (JPEG stays JPEG, etc.)
+pdfimages -all document.pdf /tmp/img
+```
+
+Then Read `/tmp/img-000.png` (etc.) to see each extracted image.
+
+**Gotcha — vector graphics:** `pdfimages` extracts only raster image
+data. Charts and diagrams drawn as vector graphics (common in
+matplotlib, Excel, and R exports) will NOT appear — they are page
+content operators, not image objects. For these, rasterize the whole
+page with `pdftoppm` instead.
+
+**Gotcha — empty images:** `pdfimages` sometimes produces many tiny or
+empty image files — these are typically background masks, transparency
+layers, or decorative elements. Filter by file size to find the real
+content images.
+
+Programmatic extraction with position data:
+```python
+import fitz  # PyMuPDF
+
+doc = fitz.open("document.pdf")
+for page in doc:
+    for img in page.get_images():
+        xref = img[0]
+        pix = fitz.Pixmap(doc, xref)
+        if pix.n - pix.alpha > 3:  # CMYK or other non-RGB
+            pix = fitz.Pixmap(fitz.csRGB, pix)
+        pix.save(f"/tmp/img_{xref}.png")
+```
+
+### Extracting file attachments
+
+PDFs can contain embedded files — spreadsheets, data files, other
+documents. Common in business reports, PDF portfolios, and PDF/A-3
+compliance documents.
+
+```bash
+# List all attachments
+pdfdetach -list document.pdf
+
+# Extract all attachments to a directory
+mkdir -p /tmp/attachments
+pdfdetach -saveall -o /tmp/attachments/ document.pdf
+
+# Extract a specific attachment by number (1-based index from -list output)
+pdfdetach -save 1 -o /tmp/attachment.pdf document.pdf
+```
+
+In Python:
+```python
+import os
+from pypdf import PdfReader
+
+reader = PdfReader("document.pdf")
+for name, content_list in reader.attachments.items():
+    safe_name = os.path.basename(name)  # sanitize — name comes from the PDF
+    for content in content_list:
+        with open(f"/tmp/{safe_name}", "wb") as f:
+            f.write(content)
+```
+
+**Two attachment mechanisms exist in PDFs:** page-level file annotation
+attachments (shown as paperclip icons in viewers) and document-level
+embedded files (in the EmbeddedFiles name tree). Both `pdfdetach` and
+pypdf handle the common cases. Rich media assets (3D, video) embedded
+as annotations may not appear in the attachment list — use PyMuPDF to
+iterate page annotations for those.
+
+### Extracting form field data
+
+PDFs with interactive forms (government forms, applications, contracts)
+have fillable fields whose values can be read programmatically:
+
+```python
+from pypdf import PdfReader
+
+reader = PdfReader("form.pdf")
+
+# Text input fields only:
+fields = reader.get_form_text_fields()
+for name, value in fields.items():
+    print(f"{name}: {value}")
+
+# All field types (checkboxes, radio buttons, dropdowns too):
+all_fields = reader.get_fields() or {}
+for name, field in all_fields.items():
+    print(f"{name}: {field.get('/V', '')} (type: {field.get('/FT', '')})")
+```
+
+`get_form_text_fields()` returns only text input fields. For
+government forms and contracts that use checkboxes, radio buttons,
+and dropdowns, use `get_fields()` instead to see all field types.
+
+For comprehensive field info (types, options, defaults):
+```bash
+pdftk form.pdf dump_data_fields
+```
+
+For anything beyond reading form data — filling forms, creating forms —
+use the pdf skill at `/mnt/skills/public/pdf/SKILL.md`.
+
+### Audio, video, and other rare embedded content
+
+PDFs can occasionally embed audio, video, or 3D models. Check
+`pdfdetach -list` first — if the media appears as an attachment,
+extract with `pdfdetach -saveall`. If not, it may be a Rich Media
+annotation (harder to extract; requires PyMuPDF to iterate page
+annotations). This is very rare in practice. Most PDF viewers outside
+Adobe Acrobat do not support media playback.
+
+### Font diagnostics
+
+If text extraction produces garbled output (wrong characters, missing
+text, mojibake), check the font situation:
+
+```bash
+pdffonts document.pdf
+```
+
+Look at the "emb" column — if fonts show "no" (not embedded) with
+custom encodings, the PDF's character mapping may be broken for text
+extraction. In that case, rasterize the page and use vision instead.
+
+Also check encoding: fonts with "Custom" or "Identity-H" encoding
+without embedded CIDToGID maps can cause character substitution issues
+even when the font is technically embedded.
+
+---
+
+## Quick Reference
+
+| Task | Best Tool | Command/Code |
+|------|-----------|--------------|
+| Inspect PDF | poppler-utils | `pdfinfo`, `pdfimages -list`, `pdfdetach -list`, `pdffonts` |
+| Extract text | pdfplumber | `page.extract_text()` |
+| Extract text (CLI) | pdftotext | `pdftotext -layout input.pdf output.txt` |
+| Extract tables | pdfplumber | `page.extract_tables()` |
+| See page visually | pdftoppm | `pdftoppm -jpeg -r 150 -f N -l N` |
+| Extract images | pdfimages | `pdfimages -png input.pdf prefix` |
+| Extract attachments | pdfdetach | `pdfdetach -saveall -o /tmp/` |
+| Read form fields | pypdf | `reader.get_fields()` |
+| OCR scanned PDFs | pytesseract | Convert to image first |
+
+## PDF Form Filling, Creation, Merging, Splitting, and Other Operations
+
+This skill covers **reading and inspection** only. For filling forms,
+creating, merging, splitting, rotating, watermarking, encrypting, or
+other PDF manipulation tasks, use the public pdf skill at
+`/mnt/skills/public/pdf/SKILL.md`.

package/skills/public/playwright-cli/SKILL.md

@@ -0,0 +1,278 @@
+---
+name: playwright-cli
+description: Automates browser interactions for web testing, form filling, screenshots, and data extraction. Use when the user needs to navigate websites, interact with web pages, fill forms, take screenshots, test web applications, or extract information from web pages.
+allowed-tools: Bash(playwright-cli:*)
+---
+
+# Browser Automation with playwright-cli
+
+## Quick start
+
+```bash
+# open new browser
+playwright-cli open
+# navigate to a page
+playwright-cli goto https://playwright.dev
+# interact with the page using refs from the snapshot
+playwright-cli click e15
+playwright-cli type "page.click"
+playwright-cli press Enter
+# take a screenshot (rarely used, as snapshot is more common)
+playwright-cli screenshot
+# close the browser
+playwright-cli close
+```
+
+## Commands
+
+### Core
+
+```bash
+playwright-cli open
+# open and navigate right away
+playwright-cli open https://example.com/
+playwright-cli goto https://playwright.dev
+playwright-cli type "search query"
+playwright-cli click e3
+playwright-cli dblclick e7
+playwright-cli fill e5 "user@example.com"
+playwright-cli drag e2 e8
+playwright-cli hover e4
+playwright-cli select e9 "option-value"
+playwright-cli upload ./document.pdf
+playwright-cli check e12
+playwright-cli uncheck e12
+playwright-cli snapshot
+playwright-cli snapshot --filename=after-click.yaml
+playwright-cli eval "document.title"
+playwright-cli eval "el => el.textContent" e5
+playwright-cli dialog-accept
+playwright-cli dialog-accept "confirmation text"
+playwright-cli dialog-dismiss
+playwright-cli resize 1920 1080
+playwright-cli close
+```
+
+### Navigation
+
+```bash
+playwright-cli go-back
+playwright-cli go-forward
+playwright-cli reload
+```
+
+### Keyboard
+
+```bash
+playwright-cli press Enter
+playwright-cli press ArrowDown
+playwright-cli keydown Shift
+playwright-cli keyup Shift
+```
+
+### Mouse
+
+```bash
+playwright-cli mousemove 150 300
+playwright-cli mousedown
+playwright-cli mousedown right
+playwright-cli mouseup
+playwright-cli mouseup right
+playwright-cli mousewheel 0 100
+```
+
+### Save as
+
+```bash
+playwright-cli screenshot
+playwright-cli screenshot e5
+playwright-cli screenshot --filename=page.png
+playwright-cli pdf --filename=page.pdf
+```
+
+### Tabs
+
+```bash
+playwright-cli tab-list
+playwright-cli tab-new
+playwright-cli tab-new https://example.com/page
+playwright-cli tab-close
+playwright-cli tab-close 2
+playwright-cli tab-select 0
+```
+
+### Storage
+
+```bash
+playwright-cli state-save
+playwright-cli state-save auth.json
+playwright-cli state-load auth.json
+
+# Cookies
+playwright-cli cookie-list
+playwright-cli cookie-list --domain=example.com
+playwright-cli cookie-get session_id
+playwright-cli cookie-set session_id abc123
+playwright-cli cookie-set session_id abc123 --domain=example.com --httpOnly --secure
+playwright-cli cookie-delete session_id
+playwright-cli cookie-clear
+
+# LocalStorage
+playwright-cli localstorage-list
+playwright-cli localstorage-get theme
+playwright-cli localstorage-set theme dark
+playwright-cli localstorage-delete theme
+playwright-cli localstorage-clear
+
+# SessionStorage
+playwright-cli sessionstorage-list
+playwright-cli sessionstorage-get step
+playwright-cli sessionstorage-set step 3
+playwright-cli sessionstorage-delete step
+playwright-cli sessionstorage-clear
+```
+
+### Network
+
+```bash
+playwright-cli route "**/*.jpg" --status=404
+playwright-cli route "https://api.example.com/**" --body='{"mock": true}'
+playwright-cli route-list
+playwright-cli unroute "**/*.jpg"
+playwright-cli unroute
+```
+
+### DevTools
+
+```bash
+playwright-cli console
+playwright-cli console warning
+playwright-cli network
+playwright-cli run-code "async page => await page.context().grantPermissions(['geolocation'])"
+playwright-cli tracing-start
+playwright-cli tracing-stop
+playwright-cli video-start
+playwright-cli video-stop video.webm
+```
+
+## Open parameters
+```bash
+# Use specific browser when creating session
+playwright-cli open --browser=chrome
+playwright-cli open --browser=firefox
+playwright-cli open --browser=webkit
+playwright-cli open --browser=msedge
+# Connect to browser via extension
+playwright-cli open --extension
+
+# Use persistent profile (by default profile is in-memory)
+playwright-cli open --persistent
+# Use persistent profile with custom directory
+playwright-cli open --profile=/path/to/profile
+
+# Start with config file
+playwright-cli open --config=my-config.json
+
+# Close the browser
+playwright-cli close
+# Delete user data for the default session
+playwright-cli delete-data
+```
+
+## Snapshots
+
+After each command, playwright-cli provides a snapshot of the current browser state.
+
+```bash
+> playwright-cli goto https://example.com
+### Page
+- Page URL: https://example.com/
+- Page Title: Example Domain
+### Snapshot
+[Snapshot](.playwright-cli/page-2026-02-14T19-22-42-679Z.yml)
+```
+
+You can also take a snapshot on demand using `playwright-cli snapshot` command.
+
+If `--filename` is not provided, a new snapshot file is created with a timestamp. Default to automatic file naming, use `--filename=` when artifact is a part of the workflow result.
+
+## Browser Sessions
+
+```bash
+# create new browser session named "mysession" with persistent profile
+playwright-cli -s=mysession open example.com --persistent
+# same with manually specified profile directory (use when requested explicitly)
+playwright-cli -s=mysession open example.com --profile=/path/to/profile
+playwright-cli -s=mysession click e6
+playwright-cli -s=mysession close  # stop a named browser
+playwright-cli -s=mysession delete-data  # delete user data for persistent session
+
+playwright-cli list
+# Close all browsers
+playwright-cli close-all
+# Forcefully kill all browser processes
+playwright-cli kill-all
+```
+
+## Local installation
+
+In some cases user might want to install playwright-cli locally. If running globally available `playwright-cli` binary fails, use `npx playwright-cli` to run the commands. For example:
+
+```bash
+npx playwright-cli open https://example.com
+npx playwright-cli click e1
+```
+
+## Example: Form submission
+
+```bash
+playwright-cli open https://example.com/form
+playwright-cli snapshot
+
+playwright-cli fill e1 "user@example.com"
+playwright-cli fill e2 "password123"
+playwright-cli click e3
+playwright-cli snapshot
+playwright-cli close
+```
+
+## Example: Multi-tab workflow
+
+```bash
+playwright-cli open https://example.com
+playwright-cli tab-new https://example.com/other
+playwright-cli tab-list
+playwright-cli tab-select 0
+playwright-cli snapshot
+playwright-cli close
+```
+
+## Example: Debugging with DevTools
+
+```bash
+playwright-cli open https://example.com
+playwright-cli click e4
+playwright-cli fill e7 "test"
+playwright-cli console
+playwright-cli network
+playwright-cli close
+```
+
+```bash
+playwright-cli open https://example.com
+playwright-cli tracing-start
+playwright-cli click e4
+playwright-cli fill e7 "test"
+playwright-cli tracing-stop
+playwright-cli close
+```
+
+## Specific tasks
+
+* **Request mocking** [references/request-mocking.md](references/request-mocking.md)
+* **Running Playwright code** [references/running-code.md](references/running-code.md)
+* **Browser session management** [references/session-management.md](references/session-management.md)
+* **Storage state (cookies, localStorage)** [references/storage-state.md](references/storage-state.md)
+* **Test generation** [references/test-generation.md](references/test-generation.md)
+* **Tracing** [references/tracing.md](references/tracing.md)
+* **Video recording** [references/video-recording.md](references/video-recording.md)

package/skills/public/playwright-cli/references/request-mocking.md

@@ -0,0 +1,87 @@
+# Request Mocking
+
+Intercept, mock, modify, and block network requests.
+
+## CLI Route Commands
+
+```bash
+# Mock with custom status
+playwright-cli route "**/*.jpg" --status=404
+
+# Mock with JSON body
+playwright-cli route "**/api/users" --body='[{"id":1,"name":"Alice"}]' --content-type=application/json
+
+# Mock with custom headers
+playwright-cli route "**/api/data" --body='{"ok":true}' --header="X-Custom: value"
+
+# Remove headers from requests
+playwright-cli route "**/*" --remove-header=cookie,authorization
+
+# List active routes
+playwright-cli route-list
+
+# Remove a route or all routes
+playwright-cli unroute "**/*.jpg"
+playwright-cli unroute
+```
+
+## URL Patterns
+
+```
+**/api/users           - Exact path match
+**/api/*/details       - Wildcard in path
+**/*.{png,jpg,jpeg}    - Match file extensions
+**/search?q=*          - Match query parameters
+```
+
+## Advanced Mocking with run-code
+
+For conditional responses, request body inspection, response modification, or delays:
+
+### Conditional Response Based on Request
+
+```bash
+playwright-cli run-code "async page => {
+  await page.route('**/api/login', route => {
+    const body = route.request().postDataJSON();
+    if (body.username === 'admin') {
+      route.fulfill({ body: JSON.stringify({ token: 'mock-token' }) });
+    } else {
+      route.fulfill({ status: 401, body: JSON.stringify({ error: 'Invalid' }) });
+    }
+  });
+}"
+```
+
+### Modify Real Response
+
+```bash
+playwright-cli run-code "async page => {
+  await page.route('**/api/user', async route => {
+    const response = await route.fetch();
+    const json = await response.json();
+    json.isPremium = true;
+    await route.fulfill({ response, json });
+  });
+}"
+```
+
+### Simulate Network Failures
+
+```bash
+playwright-cli run-code "async page => {
+  await page.route('**/api/offline', route => route.abort('internetdisconnected'));
+}"
+# Options: connectionrefused, timedout, connectionreset, internetdisconnected
+```
+
+### Delayed Response
+
+```bash
+playwright-cli run-code "async page => {
+  await page.route('**/api/slow', async route => {
+    await new Promise(r => setTimeout(r, 3000));
+    route.fulfill({ body: JSON.stringify({ data: 'loaded' }) });
+  });
+}"
+```