Add domain skills: youtube/upload, dev-to/publish, google-search-console/check

domain-skills/devto/publish.md

@@ -0,0 +1,51 @@
+# devto/publish — publish an article to DEV.to via the markdown editor (battle-tested 2026-06-28)
+
+Driving `dev.to/new` with browser-harness against the user's logged-in Chrome. DEV.to gives an **instant, no-queue, high-DR dofollow backlink** in the article body — ideal for cross-posting an existing technical article. Far simpler than rich editors: it's one markdown textarea with Jekyll front matter.
+
+## Pre-flight
+- User logged into dev.to in Chrome. `new_tab("https://dev.to/new")` → if the editor (`textarea#article_body_markdown`) is present you're in; if you see a login wall, pause and ask.
+- The "basic markdown editor" puts **everything in one textarea** — title/tags/description go in YAML front matter at the top, body below.
+
+## The flow
+
+### 1. Build the content (front matter + markdown body)
+```
+---
+title: <Title, plain text>
+published: true            # true = publish now; false = save as draft
+description: <≤ ~150 chars>
+tags: programming, ai, webdev, saas    # comma-separated, MAX 4, lowercase, no spaces/hyphens inside a tag
+canonical_url: <optional — set to the original if cross-posting, to avoid duplicate-content>
+---
+
+<markdown body>
+```
+- **YouTube / Tweet embeds:** liquid tag on its own line — `{% embed https://youtu.be/<id> %}`.
+- Body links are normal markdown `[text](https://...)` and render **dofollow**.
+
+### 2. Insert it (React-safe native setter — don't type)
+The editor is one big controlled textarea. Set the value via the native setter + fire input/change (typing char-by-char is slow and flaky):
+```python
+md = open("/path/post.md").read()
+js("""(function(){
+  var t=document.querySelector('textarea#article_body_markdown')||
+        [].slice.call(document.querySelectorAll('textarea')).sort((a,b)=>b.getBoundingClientRect().height-a.getBoundingClientRect().height)[0];
+  var setter=Object.getOwnPropertyDescriptor(window.HTMLTextAreaElement.prototype,'value').set;
+  setter.call(t, %s); t.dispatchEvent(new Event('input',{bubbles:true})); t.dispatchEvent(new Event('change',{bubbles:true}));
+  return 'set:'+t.value.length;
+})()""" % json.dumps(md))
+```
+
+### 3. Publish
+- Scroll to the bottom; the button is **"Save changes"** (there is no separate "Publish" button in this editor). With `published: true` in the front matter, clicking **Save changes publishes**; with `published: false` it saves a draft.
+- Success = the URL changes to `https://dev.to/<user>/<slug>`.
+
+## Gotchas (field-tested)
+- **"Invalid authenticity token" (CSRF) on save** — the #1 failure. The Rails CSRF token goes stale if the page sat open a while (or across a failed submit). **Fix: `goto("https://dev.to/new")` to reload (fresh token), re-insert the content, save again.** Don't dwell between loading the editor and submitting.
+- **No "Publish" button** — it's "Save changes"; the `published:` front-matter flag decides draft vs live. Don't hunt for a Publish button.
+- **Tags:** max 4, lowercase, each a single token (e.g. `webdev`, not `web-dev`); invalid tags can block the save.
+- **Cover image** is optional but boosts the home-feed; drag-drop only (skip in automation, the user can add later).
+- Cross-posting the same article to multiple sites (HackerNoon, Hashnode, dev.to): set `canonical_url` to the original on the secondary copies if you care about duplicate-content; for pure-backlink plays it's optional.
+
+## Why it's worth it
+Instant publish, no moderator queue, DEV.to is high domain authority, and body links are dofollow — so a single cross-post of an existing article = one of the "5 backlinks that matter," in ~3 minutes. Hashnode works the same way (markdown editor + instant publish).

domain-skills/youtube/upload.md

@@ -0,0 +1,51 @@
+# youtube/upload — publish a video to YouTube via Studio (battle-tested 2026-06-28)
+
+Driving `studio.youtube.com` with browser-harness against the user's logged-in Chrome. This is the durable map of the upload flow — follow it and the first try works. The whole flow is ~5 steps but several controls resist JS selectors and need **coordinate clicks** (noted below).
+
+## Pre-flight
+- User must be logged into the target channel in Chrome. Confirm: `page_info()` on `studio.youtube.com` returns `.../channel/<CHANNEL_ID>` and title contains "YouTube Studio".
+- **Check for an existing video first.** The channel dashboard "Latest video performance" card shows the most recent upload — don't create a duplicate. To reuse an existing video's URL instead of uploading: go to `.../videos/upload`, scrape `a[href*="/video/"]` → `/video/(<id>)/` and build `https://youtu.be/<id>`.
+- Have the absolute path to the local `.mp4` ready.
+
+## The flow
+
+### 1. Open the upload dialog
+- Click **Create** (top-right): match `aria-label === "Create"` (an `<button>`/`ytcp-button`). Get rect, `click(cx,cy)`.
+- Menu appears with: Create post / **Upload videos** / Go live. Click the element whose trimmed innerText is exactly `Upload videos` (`children.length<=1`, width>0).
+
+### 2. Set the file (this triggers the upload immediately)
+- After the dialog opens, find file inputs via CDP and set the **last** one:
+  ```python
+  doc=cdp("DOM.getDocument", depth=-1, pierce=True)
+  nodes=cdp("DOM.querySelectorAll", nodeId=doc["root"]["nodeId"], selector='input[type=file]')["nodeIds"]
+  cdp("DOM.setFileInputFiles", files=[ABS_MP4_PATH], nodeId=nodes[-1])
+  ```
+- Wait ~8s. The dialog shows "Upload complete … Processing will begin shortly". The **public URL is available immediately** in the "Video link" anchor: scrape `a[href*="youtu.be"]` → e.g. `https://youtu.be/qm3aVsWDARY`. Capture it now.
+
+### 3. Details — title + description
+- Title and description are **contenteditable `#textbox` divs** (NOT inputs). There are two large ones; sort by `y`: first = Title (pre-filled from filename), second = Description.
+- Replace the title: `click()` it → `document.execCommand('selectAll',false,null)` → `cdp("Input.insertText", text=TITLE)`.
+- Description: `click()` it → `cdp("Input.insertText", text=DESC)`.
+- **Trap:** external links in the description are NOT clickable until the channel completes a one-off verification ("To make external links clickable, first complete a one-off verification"). The link text still shows; fine for a backlink mention.
+
+### 4. Audience — "Made for Kids" (REQUIRED, or Next is blocked)
+- Radios are `tp-yt-paper-radio-button`. The "no" option's text is literally **`No, it's not 'Made for Kids'`** (curly quotes around Made for Kids — do NOT match `/not made for kids/`; match `/no,/i` AND `/made for kids/i`).
+- `scrollIntoView({block:'center'})` then `click` its left edge (`rect.x+18, rect.y+height/2`). Verify `aria-checked === "true"`.
+
+### 5. Advance + Visibility + Publish
+- Click **Next** (trimmed innerText `Next`, width>0) **3×** with ~3s waits: Details → Video elements → Checks → Visibility. Confirm you're on Visibility (`document.body.innerText` contains "Save or publish").
+- **Visibility radios resist JS selectors — use COORDINATE clicks.** The three options stack: Private, Unlisted, **Public** (3rd). Selecting any visibility enables the bottom-right button and relabels it `Save`→`Publish`.
+  - If a JS query for the radio returns null, click by coordinate. (See coordinate-conversion note below.)
+  - Verify selection worked by checking that a `Publish`/`Save` button with `aria-disabled!=="true"` now exists near the bottom (`rect.y>700`).
+- Click **Publish**. Success = a **"Video published"** dialog appears with the share link (`youtu.be/<id>`) + Promote button.
+
+## Gotchas (field-tested)
+- **Visibility radios: coordinate clicks only.** `[role=radio]`/`tp-yt-paper-radio-button` text matches fail because the label/description live in sibling nodes. Locate the Public row from a screenshot and click it.
+- **Coordinate conversion:** screenshots come back at 2× retina (e.g. 3840 wide shown at 2000). For `click(x,y)` (CSS px on a ~1920 viewport): `css = displayed_screenshot_coord × 0.96`.
+- **Clicking Publish/Save with no visibility chosen is safely blocked** — a "You need to choose a visibility setting" tooltip shows and the Visibility step turns red; nothing publishes. So a mis-fire here is harmless; just select Public and retry.
+- **Auto-save:** the dialog header reads "Saved as private" / "Saving…" throughout — the video exists as private from the moment of upload; publishing flips it to the chosen visibility.
+- **Don't re-upload an existing video** — check the dashboard card first.
+
+## Content best-practices (for the human filling fields)
+- **Title** ≤100 chars, keyword-first. **Description**: 1–2 line hook + links (with timestamps if long). **Tags** in Show More. **Custom thumbnail** beats auto-generated for CTR. Add **end screens / cards** in the "Video elements" step if you skipped it.
+- For embedding in an article (HackerNoon, etc.): paste the `youtu.be/<id>` URL on its own line — most editors auto-embed the player. Public or Unlisted both embed.