Forem: vast cow

How to Check and Configure bcache `discard` and `cache_mode`

vast cow — Sun, 03 May 2026 07:20:14 +0000

bcache lets you use a fast device, such as an SSD, as a cache for a slower storage device, such as an HDD. This can help improve storage performance while still using larger, lower-cost disks for the main data storage.

This article explains how to check and configure two common bcache settings: discard and cache_mode.

Checking and Enabling `discard`

The discard setting controls whether bcache can notify the storage device about blocks that are no longer in use. When an SSD is involved, this is commonly related to TRIM behavior.

You can check the current discard setting with the following command:

cat /sys/block/sda/bcache/discard

To enable discard, write 1 to the setting:

echo 1 | sudo tee /sys/block/sda/bcache/discard

Once enabled, bcache can pass discard information to the underlying storage device when appropriate.

Checking and Changing `cache_mode`

The cache_mode setting controls how bcache handles write operations.

To check the current cache mode, run:

cat /sys/block/bcache0/bcache/cache_mode

To change the cache mode to writethrough, use this command:

echo writethrough | sudo tee /sys/block/bcache0/bcache/cache_mode

In writethrough mode, data is written both to the cache and to the backing storage device. This makes it a practical choice when you want a safer write behavior that does not rely only on the cache device.

Things to Check Before Running These Commands

These commands write directly to bcache settings under /sys. Before running them, make sure the device names match your actual system.

For example, your system may not use sda or bcache0. The correct device names can vary depending on your storage layout and how bcache was configured.

Summary

The discard setting allows bcache to notify storage devices about unused blocks, which can be useful in SSD-based environments.

The cache_mode setting controls bcache’s write behavior. writethrough is a straightforward and relatively safe mode because writes are sent to both the cache and the backing device.

In normal use, it is best to check the current settings first, confirm the target devices, and then apply any changes carefully.

Getting ytmusicapi Headers with Headless Chrome

vast cow — Fri, 01 May 2026 13:50:32 +0000

This script collects the request information needed to use ytmusicapi with YouTube Music. It connects to an already running Chrome or Edge browser, opens YouTube Music, watches the network traffic, and saves the relevant request headers to a JSON file.

Purpose

ytmusicapi may require header and authentication-related information from an active YouTube Music session.

This script helps collect that information by using a real browser session. It listens for requests sent to the YouTube Music internal API and captures the headers from the matching request.

The target request is:

https://music.youtube.com/youtubei/v1/browse

When the script finds a matching request, it saves the details to:

matched_request_headers.json

What the Script Does

The script performs the following steps:

Connects to an existing Chrome or Edge browser through the Chrome DevTools Protocol.
Selects an existing browser tab.
Adjusts the User-Agent so it looks like a normal Chrome browser.
Opens the YouTube Music uploads library page.
Monitors network requests from the browser.
Captures only requests that match the YouTube Music browse API endpoint.
Saves the request URL, method, resource type, and headers to a JSON file.
Returns the tab to the new tab page after collection.

Preparation

Before running the script, start Chrome or Edge with remote debugging enabled.

For example:

chrome --remote-debugging-port=9222

Depending on your operating system, you may need to use the full path to the Chrome or Edge executable.

You also need Playwright installed in your Python environment:

pip install playwright
playwright install

How to Use It

First, open Chrome or Edge with the remote debugging port enabled.

Next, sign in to YouTube Music in that browser. Since the script connects to the existing browser session, it can use your logged-in YouTube Music state.

Then run the script:

python script.py

The script will connect to the browser and navigate to:

https://music.youtube.com/library/uploads

While the page loads, it monitors network requests. If it finds a request matching the target API endpoint, it prints the request details in the console and saves them to:

matched_request_headers.json

Output

The output JSON file contains information like this:

{
  "effective_user_agent": "...",
  "matched_count": 1,
  "matched_requests": [
    {
      "url": "...",
      "url_without_query": "https://music.youtube.com/youtubei/v1/browse",
      "method": "POST",
      "resource_type": "xhr",
      "headers": {
        "...": "..."
      }
    }
  ]
}

The most important part is the headers object inside matched_requests. This contains the request headers that can be used when preparing ytmusicapi authentication or configuration data.

Why the User-Agent Is Adjusted

When Chrome runs in headless mode, its User-Agent may include the string HeadlessChrome.

The script replaces HeadlessChrome with Chrome so the browser identifies itself more like a regular Chrome browser.

This helps keep the request environment closer to a normal browser session.

How Matching Works

The script does not save every network request.

Instead, it removes query parameters from each request URL and checks whether the remaining URL exactly matches:

https://music.youtube.com/youtubei/v1/browse

This keeps the output focused and avoids saving unrelated requests such as images, scripts, stylesheets, and other API calls.

Notes

The script connects to an existing browser, so it does not close the browser when it finishes.

After collecting the request data, it tries to return the selected tab to:

chrome://new-tab-page

If no matching request is found, matched_count will be 0. In that case, check that you are signed in to YouTube Music and that the uploads library page loaded correctly.

Summary

This script is a small helper tool for collecting YouTube Music request headers for use with ytmusicapi.

It uses Playwright to connect to an existing Chrome or Edge session, opens YouTube Music, watches for the relevant internal API request, and saves the matched request headers to matched_request_headers.json. Because it works with a real logged-in browser session, the captured headers reflect the actual YouTube Music environment used by the browser.

import json
import urllib.request
from urllib.parse import urlparse
from playwright.sync_api import sync_playwright, Request, Page


# ===== Configuration =====

CDP_ENDPOINT = "http://127.0.0.1:9222"  # Existing browser CDP port
URL_A = "https://music.youtube.com/library/uploads"

# Condition B:
# Match requests whose URL, excluding query parameters, is exactly:
# https://music.youtube.com/youtubei/v1/browse
URL_B_BASE = "https://music.youtube.com/youtubei/v1/browse"

OUTPUT_JSON = "matched_request_headers.json"


def assert_cdp_available(endpoint: str) -> None:
    version_url = endpoint.rstrip("/") + "/json/version"

    try:
        with urllib.request.urlopen(version_url, timeout=3) as res:
            if res.status != 200:
                raise RuntimeError(f"CDP endpoint returned HTTP {res.status}")
    except Exception as e:
        raise RuntimeError(
            f"CDP endpoint is not available: {version_url}\n"
            f"Please start Chrome/Edge with --remote-debugging-port=9222.\n"
            f"Original error: {e}"
        ) from e


def get_url_without_query(url: str) -> str:
    """
    Return the URL without query parameters or fragments.

    Example:
      https://music.youtube.com/youtubei/v1/browse?key=abc
      -> https://music.youtube.com/youtubei/v1/browse
    """
    parsed = urlparse(url)
    return f"{parsed.scheme}://{parsed.netloc}{parsed.path}"


def matches_condition_b(url: str) -> bool:
    """
    Condition B:
    Match only when the URL without query parameters is exactly URL_B_BASE.
    """
    return get_url_without_query(url) == URL_B_BASE


def pick_existing_page(context) -> Page:
    """
    Pick one existing tab.

    Prefer an chrome://new-tab-page tab if available.
    Otherwise, use the first existing tab.
    """
    pages = context.pages

    if not pages:
        raise RuntimeError(
            "No existing tab was found. Please open at least one tab in the CDP-connected browser."
        )

    for page in pages:
        if page.url == "chrome://new-tab-page":
            return page

    return pages[0]


def get_default_user_agent(page: Page) -> str:
    """
    Read navigator.userAgent from the current page environment.

    Using the actual User-Agent from the CDP-connected browser avoids mismatch
    between the real Chrome version and the User-Agent string.
    """
    user_agent = page.evaluate("navigator.userAgent")

    if not isinstance(user_agent, str) or not user_agent.strip():
        raise RuntimeError("Failed to read navigator.userAgent")

    return user_agent


def normalize_user_agent(user_agent: str) -> str:
    """
    Replace HeadlessChrome with Chrome.

    If the User-Agent does not contain HeadlessChrome, return it unchanged.
    """
    return user_agent.replace("HeadlessChrome", "Chrome")


def get_default_platform(page: Page) -> str:
    """
    Read navigator.platform from the current page environment.

    Return an empty string if it cannot be read.
    """
    try:
        platform = page.evaluate("navigator.platform")
    except Exception:
        return ""

    if not isinstance(platform, str):
        return ""

    return platform


def spoof_user_agent(context, page: Page) -> str:
    """
    Override the User-Agent for an existing CDP-connected browser page.

    For an existing browser connected through CDP, use CDP's
    Network.setUserAgentOverride instead of new_context(user_agent=...).

    Steps:
      1. Read the current navigator.userAgent.
      2. Replace HeadlessChrome with Chrome.
      3. Apply the value using Network.setUserAgentOverride.

    Returns:
      The actual User-Agent value that was applied.
    """
    default_user_agent = get_default_user_agent(page)
    override_user_agent = normalize_user_agent(default_user_agent)
    platform = get_default_platform(page)

    print(f"Default User-Agent : {default_user_agent}")
    print(f"Override User-Agent: {override_user_agent}")
    print(f"Platform           : {platform}")

    cdp_session = context.new_cdp_session(page)

    cdp_session.send("Network.enable")

    params = {
        "userAgent": override_user_agent,
    }

    if platform:
        params["platform"] = platform

    cdp_session.send("Network.setUserAgentOverride", params)

    return override_user_agent


def main() -> None:
    matched_requests = []

    assert_cdp_available(CDP_ENDPOINT)

    with sync_playwright() as p:
        browser = p.chromium.connect_over_cdp(CDP_ENDPOINT)

        if not browser.contexts:
            raise RuntimeError("No existing browser context was found.")

        context = browser.contexts[0]
        page = pick_existing_page(context)

        # Apply User-Agent spoofing
        effective_user_agent = spoof_user_agent(context, page)

        def handle_request(request: Request) -> None:
            url = request.url

            if not matches_condition_b(url):
                return

            try:
                headers = request.all_headers()

                record = {
                    "url": url,
                    "url_without_query": get_url_without_query(url),
                    "method": request.method,
                    "resource_type": request.resource_type,
                    "headers": headers,
                }

                matched_requests.append(record)

                print("=== MATCHED REQUEST ===")
                print(json.dumps(record, ensure_ascii=False, indent=2))

            except Exception as e:
                print(f"[WARN] Failed to read headers for {url}: {e}")

        context.on("request", handle_request)

        try:
            # Navigate the existing tab to URL A
            page.goto(URL_A, wait_until="domcontentloaded")

            try:
                page.wait_for_load_state("networkidle", timeout=15_000)
            except Exception:
                pass

            output = {
                "effective_user_agent": effective_user_agent,
                "matched_count": len(matched_requests),
                "matched_requests": matched_requests,
            }

            with open(OUTPUT_JSON, "w", encoding="utf-8") as f:
                json.dump(output, f, ensure_ascii=False, indent=2)

            print(f"Saved: {OUTPUT_JSON}")
            print(f"Matched count: {len(matched_requests)}")

        finally:
            # After collection, return the existing tab to the new tab page
            try:
                page.goto("chrome://new-tab-page", wait_until="domcontentloaded")
            except Exception as e:
                print(f"[WARN] Failed to navigate tab to chrome://new-tab-page: {e}")

            # Do not close the existing browser
            # browser.close()


if __name__ == "__main__":
    main()

mdadm RAID Recovery Test Helper

vast cow — Fri, 01 May 2026 04:25:48 +0000

This script is a tool for safely testing possible RAID configurations with Linux mdadm. Its main purpose is to find a combination that can be mounted read-only without running risky mdadm --create operations directly on the original disks.

Purpose

When a RAID array is damaged or its configuration metadata is missing, you may need to determine the correct disk order, RAID level, chunk size, metadata version, layout, and data offset.

Trying these combinations directly on the original disks can be dangerous. A wrong mdadm --create command may make recovery harder or cause further damage.

This script reduces that risk by creating temporary dm-snapshot overlays for the original disks. Each test is performed against those overlay devices, not the original disks themselves. The goal is to identify a mountable configuration while keeping the source disks protected.

What It Does

The script automatically tries different RAID parameter combinations and checks whether the resulting array can be mounted in read-only mode.

It can:

Set the original devices to read-only
Create a fresh snapshot overlay for each trial
Try different disk orders
Fix known disks to specific RAID slots
Include missing slots for incomplete arrays
Test different metadata versions, chunk sizes, layouts, and data offsets
Probe the resulting array for a filesystem
Attempt a safe read-only mount
Record all results in results.csv
Save successful combinations in successes.csv
Store logs and sample file listings for later inspection
Resume from previous results after interruption

Basic Usage

A typical command looks like this:

sudo ./mdadm_try_mount.py \
  --origins /dev/sdb /dev/sdc /dev/sdd /dev/sde \
  --level 5 \
  --raid-devices 4 \
  --metadata 1.2 1.0 \
  --chunks 64K 128K 256K 512K \
  --layouts left-symmetric right-symmetric \
  --workdir /root/mdadm-try

This example tests a four-disk RAID5 array using several metadata versions, chunk sizes, and layouts.

The script creates temporary overlay devices, builds a trial array, checks whether a filesystem is detected, and then tries to mount it read-only.

Fixing Known Disk Positions

If you already know that a certain disk belongs in a specific RAID slot, use --fixed-slot.

sudo ./mdadm_try_mount.py \
  --origins /dev/sdb /dev/sdc /dev/sdd /dev/sde \
  --fixed-slot 0=/dev/sdb \
  --level 5 \
  --raid-devices 4

In this example, /dev/sdb is fixed to slot 0. The script will only permute the remaining devices across the remaining slots.

This is useful when you have partial information from labels, old notes, enclosure order, or previous RAID metadata.

Testing Arrays with Missing Disks

For RAID levels that can tolerate missing devices, such as RAID5 or RAID6, the script can also test combinations that include missing slots.

sudo ./mdadm_try_mount.py \
  --origins /dev/sdb /dev/sdc /dev/sdd \
  --level 5 \
  --raid-devices 4 \
  --include-missing \
  --max-missing 1

This example assumes the original array had four devices, but only three are available. The script will test possible placements of the available disks and one missing slot.

Checking the Results

The main output files are created under the working directory.

results.csv
successes.csv
logs/
samples/

results.csv contains every trial, including failed attempts.

successes.csv contains only the combinations that mounted successfully.

When a trial succeeds, the script also saves a sample list of files found on the mounted filesystem. This helps you judge whether the recovered layout looks correct.

Resuming an Interrupted Run

Large searches can take a long time. If a run is interrupted, you can resume from the existing results file:

sudo ./mdadm_try_mount.py \
  --resume-from-results \
  ...

The script reads the latest trial ID from results.csv and continues from the next trial.

You can also resume manually with --resume-from followed by a trial number.

Safety Notes

The most important rule is simple: do not run mdadm --create directly on the original disks.

This script is designed to pass only /dev/mapper/mdtry_* overlay devices to mdadm --create, but you should still check your device names carefully before running it.

The working directory must be on a normal disk with enough free space for the copy-on-write files. The script rejects tmpfs and ramfs because they would store COW data in memory.

Summary

This script is intended for the early investigation stage of RAID recovery. It helps narrow down the correct RAID configuration by safely testing many possible combinations and recording the results.

It is especially useful when:

The disk order is unknown
The chunk size or layout is uncertain
Some disks may be missing
You need to test metadata versions or data offsets
You want a repeatable record of every trial
You want to avoid modifying the original disks

Used carefully, it provides a structured way to search for a mountable RAID configuration while minimizing risk to the original media.

#!/usr/bin/env python3
"""
mdadm_try_mount.py

Safely test mdadm --create parameter combinations on dm-snapshot overlays,
then collect combinations that successfully mount read-only.

Features:
  - dm-snapshot overlay per trial
  - --fixed-slot SLOT=DEVICE
  - tqdm progress bar with estimated total trials
  - read-only mount checks
  - success extraction to successes.csv

IMPORTANT:
  Do NOT run mdadm --create directly on original disks.
  This script passes only /dev/mapper/mdtry_* overlay devices to mdadm --create.
"""

import argparse
import csv
import itertools
import math
import os
import re
import shlex
import shutil
import subprocess
import sys
import time
from pathlib import Path
from typing import Dict, Iterable, Iterator, List, Optional, Sequence, Tuple

from tqdm import tqdm


# -----------------------------
# Basic command helpers
# -----------------------------

def run(
    cmd: Sequence[str],
    check: bool = False,
    capture: bool = True,
    timeout: Optional[int] = None,
    quiet: bool = False,
) -> subprocess.CompletedProcess:
    if not quiet:
        tqdm.write("+ " + " ".join(shlex.quote(str(x)) for x in cmd))

    return subprocess.run(
        list(map(str, cmd)),
        check=check,
        text=True,
        stdout=subprocess.PIPE if capture else None,
        stderr=subprocess.PIPE if capture else None,
        timeout=timeout,
    )


def require_root() -> None:
    if os.geteuid() != 0:
        raise SystemExit("ERROR: please run as root.")


def require_tools(tools: Sequence[str]) -> None:
    missing = [tool for tool in tools if shutil.which(tool) is None]
    if missing:
        raise SystemExit(f"ERROR: required command(s) not found: {', '.join(missing)}")


def write_text(path: Path, text: str) -> None:
    path.parent.mkdir(parents=True, exist_ok=True)
    path.write_text(text or "", encoding="utf-8", errors="replace")


def safe_name(dev: str) -> str:
    return re.sub(r"[^A-Za-z0-9_.-]+", "_", dev.strip("/"))


def device_exists(dev: str) -> bool:
    return Path(dev).exists()


# -----------------------------
# Block / filesystem helpers
# -----------------------------

def filesystem_type_for_path(path: Path) -> str:
    path.mkdir(parents=True, exist_ok=True)

    cp = run(
        ["findmnt", "-n", "-o", "FSTYPE", "-T", str(path)],
        check=True,
        quiet=True,
    )
    return cp.stdout.strip()


def ensure_workdir_not_tmpfs(workdir: Path) -> None:
    fstype = filesystem_type_for_path(workdir)

    if fstype in {"tmpfs", "ramfs"}:
        raise SystemExit(
            f"ERROR: workdir={workdir} is {fstype}.\n"
            "This is unsafe because COW files will consume RAM.\n"
            "Specify a --workdir path on a normal physical disk."
        )

    tqdm.write(f"workdir filesystem: {fstype}")


def get_sectors(dev: str) -> int:
    cp = run(["blockdev", "--getsz", dev], check=True, quiet=True)
    return int(cp.stdout.strip())


def set_readonly(dev: str) -> None:
    run(["blockdev", "--setro", dev], check=False, quiet=True)

    cp = run(["blockdev", "--getro", dev], check=True, quiet=True)
    if cp.stdout.strip() != "1":
        raise RuntimeError(f"{dev} could not be set to read-only")

    tqdm.write(f"{dev}: read-only")


# -----------------------------
# mdadm / dmsetup / loop helpers
# -----------------------------

def stop_md(mddev: str, quiet: bool = True) -> None:
    run(["mdadm", "--stop", mddev], check=False, quiet=quiet)


def make_cow_file(path: Path, size: str, quiet: bool = True) -> str:
    path.parent.mkdir(parents=True, exist_ok=True)

    run(["truncate", "-s", size, str(path)], check=True, quiet=quiet)

    cp = run(["losetup", "-f", "--show", str(path)], check=True, quiet=quiet)
    loopdev = cp.stdout.strip()

    if not loopdev:
        raise RuntimeError(f"losetup failed for {path}")

    return loopdev


def detach_loop(loopdev: str, quiet: bool = True) -> None:
    if loopdev:
        run(["losetup", "-d", loopdev], check=False, quiet=quiet)


def create_snapshot_overlay(
    origin: str,
    cow_loop: str,
    mapper_name: str,
    snapshot_chunk_sectors: int,
    quiet: bool = True,
) -> str:
    sectors = get_sectors(origin)
    table = f"0 {sectors} snapshot {origin} {cow_loop} N {snapshot_chunk_sectors}"

    run(["dmsetup", "create", mapper_name, "--table", table], check=True, quiet=quiet)

    return f"/dev/mapper/{mapper_name}"


def remove_mapper(name: str, quiet: bool = True) -> None:
    if name:
        run(["dmsetup", "remove", name], check=False, quiet=quiet)


def dm_status(names: Sequence[str]) -> str:
    out: List[str] = []

    for name in names:
        cp = run(["dmsetup", "status", name], check=False, quiet=True)
        text = ((cp.stdout or "") + (cp.stderr or "")).strip()
        out.append(f"{name}: {text}")

    return "\n".join(out)


# -----------------------------
# Probe / mount helpers
# -----------------------------

def blkid_probe(dev: str) -> str:
    cp = run(["blkid", "-p", dev], check=False, quiet=True)
    return ((cp.stdout or "") + (cp.stderr or "")).strip()


def file_probe(dev: str) -> str:
    cp = run(["file", "-s", dev], check=False, quiet=True)
    return ((cp.stdout or "") + (cp.stderr or "")).strip()


def detect_fs(blkid_text: str, file_text: str) -> Optional[str]:
    combined = f"{blkid_text}\n{file_text}".lower()

    m = re.search(r'type="([^"]+)"', blkid_text, re.IGNORECASE)
    if m:
        return m.group(1).lower()

    for fs in [
        "ext4",
        "ext3",
        "ext2",
        "xfs",
        "btrfs",
        "vfat",
        "ntfs",
        "exfat",
    ]:
        if fs in combined:
            return fs

    if "crypto_luks" in combined or "luks" in combined:
        return "luks"

    if "lvm2_member" in combined or "lvm" in combined:
        return "lvm"

    return None


def mount_options_for_fs(fs_type: str) -> Tuple[List[str], str]:
    fs_type = fs_type.lower()

    if fs_type in {"ext4", "ext3", "ext2"}:
        return ["-o", "ro,noload"], "ro,noload"

    if fs_type == "xfs":
        return ["-o", "ro,norecovery"], "ro,norecovery"

    if fs_type in {"btrfs", "vfat", "ntfs", "exfat"}:
        return ["-o", "ro"], "ro"

    return ["-o", "ro"], "ro"


def try_mount(mddev: str, mnt: Path, fs_type: Optional[str]) -> Tuple[bool, str, str]:
    mnt.mkdir(parents=True, exist_ok=True)

    if not fs_type:
        return False, "", "unknown filesystem"

    if fs_type in {"luks", "lvm"}:
        return False, "", f"{fs_type}: is not a direct mount target"

    opts, opts_text = mount_options_for_fs(fs_type)

    cp = run(
        ["mount", "-t", fs_type] + opts + [mddev, str(mnt)],
        check=False,
        timeout=30,
        quiet=True,
    )
    out = ((cp.stdout or "") + (cp.stderr or "")).strip()

    if cp.returncode == 0:
        return True, opts_text, out

    cp2 = run(
        ["mount", "-o", "ro", mddev, str(mnt)],
        check=False,
        timeout=30,
        quiet=True,
    )
    out2 = ((cp2.stdout or "") + (cp2.stderr or "")).strip()

    if cp2.returncode == 0:
        return True, "ro(auto)", out2

    return False, opts_text, f"{out}\n{out2}".strip()


def unmount(mnt: Path, quiet: bool = True) -> None:
    run(["umount", str(mnt)], check=False, quiet=quiet)


def list_sample_files(mnt: Path, limit: int = 100) -> List[str]:
    samples: List[str] = []

    try:
        for root, dirs, filenames in os.walk(mnt):
            dirs.sort()
            filenames.sort()

            for filename in filenames:
                p = Path(root) / filename
                rel = p.relative_to(mnt)
                samples.append(str(rel))

                if len(samples) >= limit:
                    return samples

    except Exception as exc:
        samples.append(f"ERROR listing files: {exc}")

    return samples


# -----------------------------
# fixed-slot handling
# -----------------------------

def parse_fixed_slots(
    fixed_slot_args: Sequence[str],
    origins: Sequence[str],
    raid_devices: int,
) -> Dict[int, str]:
    """
    Parse:
      --fixed-slot 2=/dev/sdk
      --fixed-slot 3:/dev/sdm

    Returns:
      {2: "/dev/sdk", 3: "/dev/sdm"}
    """
    fixed: Dict[int, str] = {}
    origin_set = set(origins)

    for item in fixed_slot_args:
        if "=" in item:
            left, right = item.split("=", 1)
        elif ":" in item:
            left, right = item.split(":", 1)
        else:
            raise SystemExit(
                f"ERROR: invalid --fixed-slot format: {item}\n"
                "Use SLOT=DEVICE, e.g. --fixed-slot 3=/dev/sdm"
            )

        left = left.strip()
        right = str(Path(right.strip()))

        if not left.isdigit():
            raise SystemExit(f"ERROR: fixed slot is not numeric: {item}")

        slot = int(left)

        if slot < 0 or slot >= raid_devices:
            raise SystemExit(
                f"ERROR: fixed slot out of range: slot={slot}, raid_devices={raid_devices}"
            )

        if not device_exists(right):
            raise SystemExit(f"ERROR: fixed-slot device not found: {right}")

        if right not in origin_set:
            raise SystemExit(
                f"ERROR: fixed-slot device {right} is not included in --origins.\n"
                "Add it to --origins as well."
            )

        if slot in fixed and fixed[slot] != right:
            raise SystemExit(
                f"ERROR: slot {slot} is assigned multiple devices: {fixed[slot]} and {right}"
            )

        if right in fixed.values():
            prev = [s for s, d in fixed.items() if d == right][0]
            raise SystemExit(
                f"ERROR: device {right} is assigned to multiple slots: {prev} and {slot}"
            )

        fixed[slot] = right

    return fixed


def fixed_slots_to_labels(
    fixed_slots: Dict[int, str],
    dev_to_label: Dict[str, str],
) -> Dict[int, str]:
    return {slot: dev_to_label[dev] for slot, dev in fixed_slots.items()}


# -----------------------------
# Combination generators
# -----------------------------

def iter_orders(
    dev_labels: Sequence[str],
    raid_devices: int,
    fixed_slots: Dict[int, str],
    include_missing: bool,
    max_missing: int,
    deduplicate: bool = True,
) -> Iterator[Tuple[str, ...]]:
    """
    Generate slot arrays of length raid_devices.

    fixed_slots:
      {slot_index: label}

    If fixed_slots exist, only unknown slots are permuted.

    If include_missing:
      unknown slots may also be filled with "missing", up to max_missing total.
      Fixed slots are never replaced with missing.
    """
    if raid_devices <= 0:
        raise SystemExit("ERROR: raid_devices must be > 0")

    all_slots = list(range(raid_devices))
    fixed_slot_set = set(fixed_slots.keys())
    unknown_slots = [s for s in all_slots if s not in fixed_slot_set]

    fixed_labels = set(fixed_slots.values())
    remaining_labels = [x for x in dev_labels if x not in fixed_labels]

    if len(fixed_labels) != len(fixed_slots):
        raise SystemExit("ERROR: duplicate fixed slot labels detected")

    if len(remaining_labels) > len(unknown_slots):
        raise SystemExit(
            "ERROR: unfixed origin devices are more than available unknown slots.\n"
            f"remaining_labels={len(remaining_labels)}, unknown_slots={len(unknown_slots)}"
        )

    seen = set()

    def emit(order: Tuple[str, ...]) -> Optional[Tuple[str, ...]]:
        if not deduplicate:
            return order

        if order in seen:
            return None

        seen.add(order)
        return order

    def build_order_for_unknown(values: Sequence[str]) -> Tuple[str, ...]:
        arr: List[Optional[str]] = [None] * raid_devices

        for slot, label in fixed_slots.items():
            arr[slot] = label

        for slot, value in zip(unknown_slots, values):
            arr[slot] = value

        unresolved = [i for i, v in enumerate(arr) if v is None]
        if unresolved:
            raise RuntimeError(f"internal error: unresolved slots: {unresolved}")

        return tuple(str(x) for x in arr)

    # No-missing case.
    if len(remaining_labels) == len(unknown_slots):
        for perm in itertools.permutations(remaining_labels):
            order = build_order_for_unknown(perm)
            out = emit(order)
            if out is not None:
                yield out

    # Missing cases.
    if include_missing:
        if max_missing < 0:
            raise SystemExit("ERROR: max_missing must be >= 0")

        max_missing_effective = min(max_missing, len(unknown_slots))

        for missing_count in range(1, max_missing_effective + 1):
            value_count = len(unknown_slots) - missing_count

            if value_count > len(remaining_labels):
                continue

            for missing_slots_local in itertools.combinations(range(len(unknown_slots)), missing_count):
                missing_slots_local_set = set(missing_slots_local)

                for chosen_labels in itertools.permutations(remaining_labels, value_count):
                    values: List[str] = []
                    it = iter(chosen_labels)

                    for local_idx in range(len(unknown_slots)):
                        if local_idx in missing_slots_local_set:
                            values.append("missing")
                        else:
                            values.append(next(it))

                    order = build_order_for_unknown(values)
                    out = emit(order)
                    if out is not None:
                        yield out


def iter_combos(
    orders: Iterable[Tuple[str, ...]],
    metadata: Sequence[str],
    chunks: Sequence[str],
    layouts: Sequence[str],
    data_offsets: Sequence[str],
) -> Iterator[Tuple[Tuple[str, ...], str, str, str, Optional[str]]]:
    offsets: Sequence[Optional[str]]

    if data_offsets:
        offsets = list(data_offsets)
    else:
        offsets = [None]

    for order in orders:
        for meta in metadata:
            for chunk in chunks:
                for layout in layouts:
                    for data_offset in offsets:
                        yield order, meta, chunk, layout, data_offset


# -----------------------------
# Count estimation for tqdm
# -----------------------------

def nperm(n: int, r: int) -> int:
    if r < 0 or r > n:
        return 0
    return math.factorial(n) // math.factorial(n - r)


def estimate_order_count(
    dev_labels: Sequence[str],
    raid_devices: int,
    fixed_slots: Dict[int, str],
    include_missing: bool,
    max_missing: int,
) -> int:
    unknown_slots_count = raid_devices - len(fixed_slots)
    fixed_labels = set(fixed_slots.values())
    remaining_labels_count = len([x for x in dev_labels if x not in fixed_labels])

    if unknown_slots_count < 0:
        return 0

    total = 0

    # No-missing case.
    if remaining_labels_count == unknown_slots_count:
        total += math.factorial(remaining_labels_count)

    # Missing cases.
    if include_missing:
        max_missing_effective = min(max_missing, unknown_slots_count)

        for missing_count in range(1, max_missing_effective + 1):
            value_count = unknown_slots_count - missing_count

            if value_count > remaining_labels_count:
                continue

            missing_slot_choices = math.comb(unknown_slots_count, missing_count)
            device_orders = nperm(remaining_labels_count, value_count)

            total += missing_slot_choices * device_orders

    return total


def estimate_combo_count(
    dev_labels: Sequence[str],
    raid_devices: int,
    fixed_slots: Dict[int, str],
    include_missing: bool,
    max_missing: int,
    metadata: Sequence[str],
    chunks: Sequence[str],
    layouts: Sequence[str],
    data_offsets: Sequence[str],
    limit: int,
) -> int:
    order_count = estimate_order_count(
        dev_labels=dev_labels,
        raid_devices=raid_devices,
        fixed_slots=fixed_slots,
        include_missing=include_missing,
        max_missing=max_missing,
    )

    offset_count = len(data_offsets) if data_offsets else 1

    total = (
        order_count
        * len(metadata)
        * len(chunks)
        * len(layouts)
        * offset_count
    )

    if limit and limit > 0:
        total = min(total, limit)

    return total


# -----------------------------
# CSV helpers
# -----------------------------

RESULT_FIELDS = [
    "try_id",
    "mount_success",
    "fs_type",
    "mount_options",
    "level",
    "raid_devices",
    "metadata",
    "chunk",
    "layout",
    "data_offset",
    "order",
    "fixed_slots",
    "blkid",
    "file",
    "mount_message",
    "sample_file",
]


def sanitize_csv_text(text: str) -> str:
    return (text or "").replace("\n", " ").replace("\r", " ").strip()


def format_fixed_slots(fixed_slots: Dict[int, str]) -> str:
    return " ".join(f"{slot}={label}" for slot, label in sorted(fixed_slots.items()))


def parse_try_id(value: str) -> int:
    """Parse try_id values such as 123, 000123, or 000123.

    The try_id in the first column of results.csv is a zero-padded string such as 000001, but
    the CLI also accepts plain numbers such as 123.
    """
    text = str(value).strip()

    if not text.isdigit():
        raise argparse.ArgumentTypeError(
            f"try_id must be numeric, got: {value!r}"
        )

    n = int(text)

    if n < 0:
        raise argparse.ArgumentTypeError("try_id must be >= 0")

    return n


def latest_try_id_from_results_csv(path: Path) -> int:
    """Return the largest numeric try_id in results.csv, or 0 if unavailable."""
    if not path.exists():
        return 0

    latest = 0

    with path.open("r", newline="", encoding="utf-8") as f:
        reader = csv.DictReader(f)

        if not reader.fieldnames or "try_id" not in reader.fieldnames:
            return 0

        for row in reader:
            raw = (row.get("try_id") or "").strip()
            if raw.isdigit():
                latest = max(latest, int(raw))

    return latest


# -----------------------------
# Args
# -----------------------------

def parse_args() -> argparse.Namespace:
    parser = argparse.ArgumentParser(
        description=(
            "Safely test mdadm --create combinations on dm-snapshot overlays "
            "and collect read-only mount successes."
        )
    )

    parser.add_argument(
        "--origins",
        nargs="+",
        required=True,
        help="Origin devices. Example: /dev/sdb /dev/sdc /dev/sdd",
    )

    parser.add_argument(
        "--fixed-slot",
        action="append",
        default=[],
        help=(
            "Fix known slots. Can be specified multiple times."
            "Example: --fixed-slot 2=/dev/sdk --fixed-slot 3=/dev/sdm"
        ),
    )

    parser.add_argument(
        "--level",
        required=True,
        help="RAID level. Examples: 1, 5, 6, 10, raid5, raid6",
    )

    parser.add_argument(
        "--raid-devices",
        type=int,
        required=True,
        help="Total number of devices in the original RAID array",
    )

    parser.add_argument(
        "--metadata",
        nargs="+",
        default=["1.2"],
        help="Metadata versions to try. Example: 1.2 1.0 0.90",
    )

    parser.add_argument(
        "--chunks",
        nargs="+",
        default=["512K"],
        help="Chunk sizes to try. Example: 64K 128K 256K 512K 1024K",
    )

    parser.add_argument(
        "--layouts",
        nargs="+",
        default=["left-symmetric"],
        help=(
            "Layouts to try. RAID5/6 examples: "
            "left-symmetric left-asymmetric right-symmetric right-asymmetric。"
            "Specify none if unnecessary, such as for RAID1."
        ),
    )

    parser.add_argument(
        "--data-offsets",
        nargs="*",
        default=[],
        help="Data offsets to try. Example: 264192s 2048K. If empty, no data offset is specified.",
    )

    parser.add_argument(
        "--mddev",
        default="/dev/md127",
        help="md device used for trials. default: /dev/md127",
    )

    parser.add_argument(
        "--workdir",
        default="/root/mdadm-try",
        help="Working directory. tmpfs/ramfs is rejected.",
    )

    parser.add_argument(
        "--cow-size",
        default="4G",
        help="COW size for each overlay. default: 4G",
    )

    parser.add_argument(
        "--snapshot-chunk-sectors",
        type=int,
        default=1024,
        help="dm-snapshot chunk size in sectors. default: 1024 = 512KiB",
    )

    parser.add_argument(
        "--include-missing",
        action="store_true",
        help="Also try combinations that include missing slots",
    )

    parser.add_argument(
        "--max-missing",
        type=int,
        default=1,
        help="Maximum number of missing slots. Use 1 for RAID5, 2 for RAID6, etc.",
    )

    parser.add_argument(
        "--limit",
        type=int,
        default=0,
        help="Maximum number of trials. 0 means unlimited.",
    )

    parser.add_argument(
        "--resume-from",
        type=parse_try_id,
        default=0,
        metavar="TRY_ID",
        help=(
            "Resume from the try_id in the first column of results.csv."
            "Trials up to the specified try_id are skipped, and appending resumes from the next try_id."
            "Example: --resume-from 123 or --resume-from 000123"
        ),
    )

    parser.add_argument(
        "--resume-from-results",
        action="store_true",
        help=(
            "Read the maximum try_id from the first column of the existing results.csv,"
            "then automatically resume from the next try_id."
        ),
    )

    parser.add_argument(
        "--no-setro",
        action="store_true",
        help="Do not run blockdev --setro on origin devices",
    )

    parser.add_argument(
        "--no-deduplicate-orders",
        action="store_true",
        help="Disable order deduplication. This saves memory but may increase duplicate trials.",
    )

    parser.add_argument(
        "--sample-limit",
        type=int,
        default=100,
        help="Number of sample file paths to save on successful mount. default: 100",
    )

    parser.add_argument(
        "--keep-cow-on-success",
        action="store_true",
        help=(
            "Keep COW/mapper/loop devices on successful mount."
            "For further investigation. Be careful: leaving them in place consumes disk space and memory."
        ),
    )

    parser.add_argument(
        "--no-progress",
        action="store_true",
        help="Disable tqdm progress display",
    )

    parser.add_argument(
        "--verbose-commands",
        action="store_true",
        help="Show each command verbosely. This may disrupt tqdm display.",
    )

    return parser.parse_args()


# -----------------------------
# Main
# -----------------------------

def main() -> int:
    args = parse_args()

    require_root()

    require_tools([
        "mdadm",
        "dmsetup",
        "losetup",
        "truncate",
        "blockdev",
        "blkid",
        "file",
        "mount",
        "umount",
        "findmnt",
    ])

    origins = [str(Path(x)) for x in args.origins]

    for dev in origins:
        if not device_exists(dev):
            raise SystemExit(f"ERROR: device not found: {dev}")

    if args.max_missing < 0:
        raise SystemExit("ERROR: --max-missing must be >= 0")

    if args.raid_devices <= 0:
        raise SystemExit("ERROR: --raid-devices must be > 0")

    if len(origins) > args.raid_devices:
        raise SystemExit(
            f"ERROR: origins count exceeds raid_devices: origins={len(origins)}, "
            f"raid_devices={args.raid_devices}"
        )

    workdir = Path(args.workdir)
    ensure_workdir_not_tmpfs(workdir)

    logs_dir = workdir / "logs"
    cow_dir = workdir / "cow"
    mnt_base = workdir / "mnt"
    sample_dir = workdir / "samples"

    results_csv = workdir / "results.csv"
    successes_csv = workdir / "successes.csv"

    resume_from = args.resume_from
    if args.resume_from_results:
        detected_resume_from = latest_try_id_from_results_csv(results_csv)
        resume_from = max(resume_from, detected_resume_from)

    if resume_from < 0:
        raise SystemExit("ERROR: --resume-from must be >= 0")

    for directory in [logs_dir, cow_dir, mnt_base, sample_dir]:
        directory.mkdir(parents=True, exist_ok=True)

    labels = [safe_name(dev) for dev in origins]
    dev_to_label: Dict[str, str] = dict(zip(origins, labels))
    label_to_origin: Dict[str, str] = dict(zip(labels, origins))

    fixed_slots_dev = parse_fixed_slots(
        fixed_slot_args=args.fixed_slot,
        origins=origins,
        raid_devices=args.raid_devices,
    )
    fixed_slots_label = fixed_slots_to_labels(
        fixed_slots=fixed_slots_dev,
        dev_to_label=dev_to_label,
    )

    tqdm.write("Origins:")
    for label, origin in label_to_origin.items():
        tqdm.write(f"  {label}: {origin}")

    if fixed_slots_label:
        tqdm.write("\nFixed slots:")
        for slot, label in sorted(fixed_slots_label.items()):
            tqdm.write(f"  slot {slot}: {label_to_origin[label]} ({label})")
    else:
        tqdm.write("\nFixed slots: none")

    if not args.no_setro:
        tqdm.write("\nSetting origin devices to read-only.")
        for dev in origins:
            set_readonly(dev)
    else:
        tqdm.write("\nWARNING: --no-setro was specified. Origin devices were not set to read-only.")

    deduplicate_orders = not args.no_deduplicate_orders

    order_iter = iter_orders(
        dev_labels=labels,
        raid_devices=args.raid_devices,
        fixed_slots=fixed_slots_label,
        include_missing=args.include_missing,
        max_missing=args.max_missing,
        deduplicate=deduplicate_orders,
    )

    combo_iter = iter_combos(
        orders=order_iter,
        metadata=args.metadata,
        chunks=args.chunks,
        layouts=args.layouts,
        data_offsets=args.data_offsets,
    )

    fixed_slots_text = format_fixed_slots(fixed_slots_label)

    total_combos = estimate_combo_count(
        dev_labels=labels,
        raid_devices=args.raid_devices,
        fixed_slots=fixed_slots_label,
        include_missing=args.include_missing,
        max_missing=args.max_missing,
        metadata=args.metadata,
        chunks=args.chunks,
        layouts=args.layouts,
        data_offsets=args.data_offsets,
        limit=args.limit,
    )

    tqdm.write(f"\nEstimated total tries: {total_combos}")

    if resume_from:
        tqdm.write(
            f"Resume: skipping completed try_id <= {resume_from:06d}; "
            f"next try_id is {resume_from + 1:06d}"
        )

    if total_combos == 0:
        raise SystemExit(
            "ERROR: The number of trials is 0.\n"
            "Check the combination of --origins, --fixed-slot, --raid-devices, and --include-missing."
        )

    append_results = resume_from > 0 and results_csv.exists()
    append_successes = resume_from > 0 and successes_csv.exists()

    progress_initial = min(resume_from, total_combos) if resume_from else 0

    with results_csv.open("a" if append_results else "w", newline="", encoding="utf-8") as rf, \
         successes_csv.open("a" if append_successes else "w", newline="", encoding="utf-8") as sf:

        result_writer = csv.DictWriter(rf, fieldnames=RESULT_FIELDS)
        success_writer = csv.DictWriter(sf, fieldnames=RESULT_FIELDS)

        if not append_results:
            result_writer.writeheader()
        if not append_successes:
            success_writer.writeheader()

        progress = tqdm(
            total=total_combos,
            initial=progress_initial,
            unit="try",
            dynamic_ncols=True,
            disable=args.no_progress,
            desc="mdadm trials",
        )

        try:
            for idx, (order, meta, chunk, layout, data_offset) in enumerate(combo_iter, 1):
                if args.limit and idx > args.limit:
                    tqdm.write(f"limit reached: {args.limit}")
                    break

                if resume_from and idx <= resume_from:
                    continue

                try_id = f"{idx:06d}"

                mapper_names: List[str] = []
                loopdevs: List[str] = []
                overlay_for_label: Dict[str, str] = {}

                mnt = mnt_base / f"try_{try_id}"

                blkid_text = ""
                file_text = ""
                fs_type = ""
                mount_success = False
                mount_options = ""
                mount_message = ""
                sample_file = ""

                keep_current = False
                quiet_commands = not args.verbose_commands

                try:
                    stop_md(args.mddev, quiet=quiet_commands)

                    # Create fresh overlays for this try.
                    for label, origin in label_to_origin.items():
                        cow_file = cow_dir / f"{try_id}_{label}.cow"
                        loopdev = make_cow_file(cow_file, args.cow_size, quiet=quiet_commands)
                        loopdevs.append(loopdev)

                        mapper_name = f"mdtry_{try_id}_{label}"
                        mapper_names.append(mapper_name)

                        overlay_dev = create_snapshot_overlay(
                            origin=origin,
                            cow_loop=loopdev,
                            mapper_name=mapper_name,
                            snapshot_chunk_sectors=args.snapshot_chunk_sectors,
                            quiet=quiet_commands,
                        )

                        overlay_for_label[label] = overlay_dev

                    mdadm_cmd: List[str] = [
                        "mdadm",
                        "--create",
                        args.mddev,
                        "--assume-clean",
                        "--readonly",
                        "--force",
                        f"--metadata={meta}",
                        f"--level={args.level}",
                        f"--raid-devices={args.raid_devices}",
                        f"--chunk={chunk}",
                    ]

                    if layout.lower() not in {"", "none", "null", "-"}:
                        mdadm_cmd.append(f"--layout={layout}")

                    if data_offset:
                        mdadm_cmd.append(f"--data-offset={data_offset}")

                    for slot in order:
                        if slot == "missing":
                            mdadm_cmd.append("missing")
                        else:
                            mdadm_cmd.append(overlay_for_label[slot])

                    cp_create = run(
                        mdadm_cmd,
                        check=False,
                        timeout=90,
                        quiet=quiet_commands,
                    )

                    write_text(logs_dir / f"{try_id}.mdadm.stdout.log", cp_create.stdout or "")
                    write_text(logs_dir / f"{try_id}.mdadm.stderr.log", cp_create.stderr or "")

                    if cp_create.returncode != 0:
                        mount_message = "mdadm create failed"
                    else:
                        time.sleep(2)

                        write_text(
                            logs_dir / f"{try_id}.dmstatus.after-create.log",
                            dm_status(mapper_names),
                        )

                        blkid_text = blkid_probe(args.mddev)
                        file_text = file_probe(args.mddev)

                        fs = detect_fs(blkid_text, file_text)
                        fs_type = fs or ""

                        mount_success, mount_options, mount_message = try_mount(
                            args.mddev,
                            mnt,
                            fs,
                        )

                        write_text(
                            logs_dir / f"{try_id}.dmstatus.after-mount.log",
                            dm_status(mapper_names),
                        )

                        if mount_success:
                            samples = list_sample_files(mnt, limit=args.sample_limit)
                            sample_path = sample_dir / f"{try_id}.files.txt"
                            write_text(sample_path, "\n".join(samples))
                            sample_file = str(sample_path)

                            success_log = (
                                f"ok=yes try_id={try_id} "
                                f"fs_type={fs_type or '-'} "
                                f"mount_options={mount_options or '-'} "
                                f"level={args.level} "
                                f"raid_devices={args.raid_devices} "
                                f"metadata={meta} "
                                f"chunk={chunk} "
                                f"layout={layout} "
                                f"data_offset={data_offset or '-'} "
                                f"order=\"{' '.join(order)}\" "
                                f"sample_file={sample_file}"
                            )
                            tqdm.write(success_log)

                            if args.keep_cow_on_success:
                                keep_current = True
                                tqdm.write(
                                    "WARNING: --keep-cow-on-success is set, so"
                                    "the mapper/loop/COW devices for this trial will be kept."
                                )

                except subprocess.TimeoutExpired as exc:
                    mount_message = f"timeout: {exc}"

                except Exception as exc:
                    mount_message = f"exception: {exc}"

                finally:
                    unmount(mnt, quiet=quiet_commands)

                    if not keep_current:
                        stop_md(args.mddev, quiet=quiet_commands)

                        for mapper_name in reversed(mapper_names):
                            remove_mapper(mapper_name, quiet=quiet_commands)

                        for loopdev in reversed(loopdevs):
                            detach_loop(loopdev, quiet=quiet_commands)

                        for label in labels:
                            cow_file = cow_dir / f"{try_id}_{label}.cow"
                            try:
                                cow_file.unlink(missing_ok=True)
                            except Exception:
                                pass
                    else:
                        tqdm.write(f"Kept md device: {args.mddev}")
                        tqdm.write("Kept mapper devices: " + " ".join(mapper_names))
                        tqdm.write("Kept loop devices: " + " ".join(loopdevs))

                row = {
                    "try_id": try_id,
                    "mount_success": "yes" if mount_success else "no",
                    "fs_type": fs_type,
                    "mount_options": mount_options,
                    "level": args.level,
                    "raid_devices": str(args.raid_devices),
                    "metadata": meta,
                    "chunk": chunk,
                    "layout": layout,
                    "data_offset": data_offset or "",
                    "order": " ".join(order),
                    "fixed_slots": fixed_slots_text,
                    "blkid": sanitize_csv_text(blkid_text),
                    "file": sanitize_csv_text(file_text),
                    "mount_message": sanitize_csv_text(mount_message),
                    "sample_file": sample_file,
                }

                result_writer.writerow(row)
                rf.flush()

                if mount_success:
                    success_writer.writerow(row)
                    sf.flush()

                    if args.keep_cow_on_success:
                        tqdm.write(
                            "\nStopping at the successful trial because --keep-cow-on-success is set.\n"
                            "After investigation, manually run umount / mdadm --stop / dmsetup remove / losetup -d."
                        )
                        progress.update(1)
                        break

                progress.update(1)

        finally:
            progress.close()

    tqdm.write("\nDone.")
    tqdm.write(f"All results    : {results_csv}")
    tqdm.write(f"Mount successes: {successes_csv}")

    return 0


if __name__ == "__main__":
    raise SystemExit(main())

Restoring Hidden Playback Buttons in YouTube Music

vast cow — Mon, 27 Apr 2026 08:54:58 +0000

Overview

This user script is designed to fix an issue in YouTube Music where certain playback controls—specifically the rewind and fast-forward buttons—may become hidden. It works by periodically scanning the page and restoring the visibility of these buttons when necessary.

Purpose

In some cases, YouTube Music’s interface may hide key controls such as:

The rewind (10 seconds back) button
The fast-forward (30 seconds ahead) button

When these controls are not visible, it can disrupt normal playback navigation. This script ensures that those buttons remain accessible, improving overall usability.

How to Use

1. Set Up a User Script Manager

To run this script, you need a browser extension that supports user scripts. A commonly used option is:

Tampermonkey (available for Chrome, Edge, Firefox, and others)

2. Install the Script

Open the Tampermonkey dashboard
Create a new script
Paste the provided code into the editor and save it

3. Open YouTube Music

The script automatically runs when you visit:

https://music.youtube.com/

No additional configuration is required.

How It Works (Briefly)

The script looks for playback buttons associated with rewind and fast-forward actions
If these elements have a hidden attribute, it removes it
This process runs every 5 seconds to ensure the buttons stay visible

Notes

If YouTube Music updates its interface, the script may need adjustments
The script runs periodically, but the performance impact is minimal

Summary

This simple user script helps maintain access to essential playback controls in YouTube Music. By automatically restoring hidden buttons, it provides a smoother and more consistent listening experience.

// ==UserScript==
// @name         YouTube Music Hidden Buttons Fix
// @namespace    http://tampermonkey.net/
// @version      1.1
// @description  Unhide rewind/forward buttons periodically
// @match        https://music.youtube.com/*
// @grant        none
// ==/UserScript==

(function() {
    'use strict';

    function unhideButtons() {
        // yt-icon-button elements that have a replay_10 icon as a descendant
        document.querySelectorAll(
            'yt-icon-button:has(yt-icon[icon="yt-sys-icons\\:replay_10"])'
        ).forEach(el => {
            el.removeAttribute("hidden");
        });

        // yt-icon-button elements that have a skip_forward_30 icon as a descendant
        document.querySelectorAll(
            'yt-icon-button:has(yt-icon[icon="yt-sys-icons\\:skip_forward_30"])'
        ).forEach(el => {
            el.removeAttribute("hidden");
        });
    }

    // Initial execution
    unhideButtons();

    // Re-run every 5 seconds
    setInterval(unhideButtons, 5000);
})();

Using Raspberry Pi 4, Raspberry Pi OS, and Docker to Connect Home Assistant with a Eufy IndoorCam 2K Pan & Tilt and Save Images When a Pet Is Detected

vast cow — Thu, 23 Apr 2026 08:00:06 +0000

I wanted to connect an Anker Eufy IndoorCam 2K Pan & Tilt to Home Assistant and automatically save an image whenever my pet is detected.

This article explains how to build that setup on a Raspberry Pi 4 running Raspberry Pi OS with Docker.

I’ll start with the practical setup steps needed to get everything working, then summarize the common issues and questions that tend to come up along the way.

What this setup does

The goal is straightforward. We want to create the following flow:

Run Home Assistant in Docker on a Raspberry Pi 4
Run a separate websocket bridge for Eufy
Install the Eufy Security custom integration in Home Assistant
Create an automation that saves the camera’s Event Image whenever a pet is detected

The overall structure looks like this:

Raspberry Pi OS 64-bit
  └─ Docker / Docker Compose
      ├─ Home Assistant Container
      └─ eufy-security-ws

Home Assistant
  ├─ HACS
  ├─ Eufy Security custom integration
  └─ automation
       petDetected → save Event Image as snapshot

Conclusion first

Yes, this setup works on Raspberry Pi 4 + Raspberry Pi OS + Docker.

The main points are:

Use Raspberry Pi OS 64-bit
Run Home Assistant as a container
Use the eufy_security custom integration, not the standard integration
Run eufy-security-ws as a separate container
Save the pet-detection image by calling image.snapshot on the camera’s Event Image

Step-by-step setup

1. Prepare Raspberry Pi OS

Install Raspberry Pi OS 64-bit on your Raspberry Pi 4.

I recommend using the 64-bit version rather than 32-bit. It is the safer choice for Docker and for future maintenance.

Then update the OS:

sudo apt update
sudo apt full-upgrade -y
sudo reboot

After rebooting, verify that the system is running in 64-bit mode:

uname -m

If the output is aarch64, you are on 64-bit.

2. Install Docker

Install Docker and make sure Docker Compose is available:

curl -fsSL https://get.docker.com | sh
sudo usermod -aG docker $USER
newgrp docker
docker --version
docker compose version

3. Create a working directory

Create directories for Home Assistant and the Eufy bridge data:

mkdir -p ~/ha-stack
cd ~/ha-stack

mkdir -p homeassistant/config
mkdir -p homeassistant/media/eufy_snapshots
mkdir -p eufy-security-ws

4. Create `compose.yaml`

In this setup, Home Assistant and eufy-security-ws run as separate containers.

Create ~/ha-stack/compose.yaml:

services:
  homeassistant:
    container_name: homeassistant
    image: ghcr.io/home-assistant/home-assistant:stable
    restart: unless-stopped
    privileged: true
    network_mode: host
    environment:
      TZ: Asia/Tokyo
    volumes:
      - ./homeassistant/config:/config
      - ./homeassistant/media:/media
      - /etc/localtime:/etc/localtime:ro
      - /run/dbus:/run/dbus:ro

  eufy-security-ws:
    container_name: eufy-security-ws
    image: bropat/eufy-security-ws:latest
    restart: unless-stopped
    network_mode: host
    environment:
      TZ: Asia/Tokyo
      USERNAME: 'your-eufy-mail@example.com'
      PASSWORD: 'your-password'
      COUNTRY: 'JP'
      TRUSTED_DEVICE_NAME: 'rpi4-ha'
      EVENT_DURATION_SECONDS: '10'
    volumes:
      - ./eufy-security-ws:/data

Start the containers:

docker compose up -d

Home Assistant should then be available at:

http://<your-pi-ip>:8123

5. Allow Home Assistant to write snapshots

Since the pet-detection images will be saved under /media/eufy_snapshots, Home Assistant needs permission to write there.

Add the following to ~/ha-stack/homeassistant/config/configuration.yaml:

homeassistant:
  allowlist_external_dirs:
    - /media/eufy_snapshots

This is important: do not overwrite your existing configuration.yaml.

If the file already contains a homeassistant: block, just add allowlist_external_dirs inside it.

After that, restart Home Assistant:

docker compose restart homeassistant

6. Install HACS

Because eufy_security is not a built-in integration, you need HACS.

Install it from inside the Home Assistant container:

docker exec -it homeassistant bash
wget -O - https://get.hacs.xyz | bash -
exit

Then restart Home Assistant:

docker compose restart homeassistant

After the restart, go through the HACS setup in the Home Assistant UI:

Settings → Devices & Services
Add Integration
HACS
Complete the GitHub device login flow

7. Configure the `eufy-security-ws` login settings

This part is critical.

If docker logs -f eufy-security-ws shows:

Missing one of USERNAME or PASSWORD

then your Eufy credentials are not being passed into the container.

Make sure the following variables are present in the eufy-security-ws section of compose.yaml:

USERNAME
PASSWORD
COUNTRY
TRUSTED_DEVICE_NAME
EVENT_DURATION_SECONDS

After making changes, recreate or restart the container:

docker compose up -d
docker logs -f eufy-security-ws

8. Be careful if your password contains `$`

Docker Compose may interpret $ as variable expansion.

If your password contains dollar signs, do not write it naively. A safer approach is to wrap it in single quotes and escape as needed with $$.

For example:

PASSWORD: 'pa$$word$$with$$dollar'

This is an easy place to get stuck.

9. Install the Eufy Security integration from HACS

Once HACS is available:

Go to HACS → Integrations
Search for Eufy Security
Install it
Restart Home Assistant

Then add the integration:

Settings → Devices & Services
Add Integration
Eufy Security

For the connection settings, use:

Host: 127.0.0.1
Port: 3000

10. Check the Eufy app settings

Even if Home Assistant is configured correctly, you may not receive pet-detection events unless the Eufy app itself is configured properly.

In the Eufy app, verify the following:

Pet Detection is enabled
Push notifications are enabled
Shared account settings are configured if needed

11. Confirm the created entities

If the integration is working, Home Assistant should create entities like these for your camera:

binary_sensor.living_room_pet_detected
image.living_room_event_image

The exact entity names will vary depending on your environment, so check them in the Home Assistant UI:

Settings → Devices & Services
Open the Eufy camera device
Review the entity list

12. Create `automations.yaml`

You can save an image when a pet is detected with an automation like this:

alias: Eufy pet detection posts image to Slack
description: ""
triggers:
  - trigger: state
    entity_id:
      - image.living_room_event_image
conditions:
  - condition: state
    entity_id: binary_sensor.living_room_pet_detected
    state:
      - "on"
actions:
  - variables:
      ts: "{{ now().strftime('%Y%m%d-%H%M%S') }}"
      file: /media/eufy_snapshots/pet_{{ ts }}.jpg
  - action: image.snapshot
    metadata: {}
    target:
      entity_id: image.living_room_event_image
    data:
      filename: "{{ file }}"

Replace the entity_id values with the ones from your own environment.

13. Apply the automation changes

If you edit automations.yaml directly, saving the file is not enough. Home Assistant will not automatically reload it.

You have two options.

Option 1: Reload automations from the UI

Go to Developer Tools
Go to Actions
Run automation.reload

Option 2: Restart Home Assistant

docker compose restart homeassistant

14. Verify that the automation is active

You can confirm that the automation has been loaded in several ways:

Check whether the alias appears under Settings → Automations & Scenes → Automations
Open the automation and see whether you can click Run
Review the Trace
Confirm that image files are actually being created in the target directory

To check the saved files from the shell:

ls -lh ~/ha-stack/homeassistant/media/eufy_snapshots

15. Test the full flow

Finally, test the actual detection flow:

Let your pet move in front of the camera
Confirm that binary_sensor.xxx_pet_detected changes to on
Confirm that image.xxx_event_image updates
Confirm that a JPEG file is saved under /media/eufy_snapshots

At that point, the setup is complete.

Common questions and troubleshooting

Can this really be done with Raspberry Pi 4, Raspberry Pi OS, and Docker?

Yes.

The main assumption is that you are using:

Home Assistant Container, not Home Assistant OS
A separate eufy-security-ws container
The eufy_security integration installed through HACS

So the structure is a little different from a Home Assistant OS setup that relies on add-ons.

Should I append to `configuration.yaml` or replace it?

Append to it. Do not replace it.

Most Home Assistant installations already have settings in configuration.yaml. In this case, you only need to add allowlist_external_dirs.

If there is no existing homeassistant: block:

homeassistant:
  allowlist_external_dirs:
    - /media/eufy_snapshots

If there is already a homeassistant: block, add it inside that section:

homeassistant:
  name: Home
  time_zone: Asia/Tokyo
  allowlist_external_dirs:
    - /media/eufy_snapshots

HACS does not appear under Add Integration

The most common causes are:

Home Assistant was not restarted fully
Browser cache is getting in the way
The HACS files were not installed correctly

First, restart Home Assistant:

docker compose restart homeassistant

Then hard-refresh the browser:

Windows / Linux: Ctrl + F5
Mac: Cmd + Shift + R

You can also verify that the HACS files exist:

ls ~/ha-stack/homeassistant/config/custom_components/hacs

`eufy-security-ws` says `Missing one of USERNAME or PASSWORD`

That means the Eufy credentials are not reaching the container.

Make sure the environment: section includes:

environment:
  TZ: Asia/Tokyo
  USERNAME: 'your-eufy-mail@example.com'
  PASSWORD: 'your-password'
  COUNTRY: 'JP'
  TRUSTED_DEVICE_NAME: 'rpi4-ha'
  EVENT_DURATION_SECONDS: '10'

What if the password contains `$`?

Be careful.

Docker Compose treats $ specially, so passwords containing dollar signs can break unless written correctly.

For example:

PASSWORD: 'pa$$word$$with$$dollar'

This is one of the most common small but frustrating issues in the setup.

How can I tell whether `automations.yaml` has been applied?

Use the following checklist:

Run automation.reload
Open Settings → Automations & Scenes → Automations
Confirm that your automation alias appears
Try running it manually
Check whether an image file is saved in the destination directory

The key point is that editing automations.yaml alone does not automatically apply the changes.

Do I need live video streaming too?

Not for this use case.

If your goal is simply to save an image when a pet is detected, then using only the Event Image is lighter and easier to manage, especially on a Raspberry Pi 4.

Once you add live streaming or recording, the load and the number of moving parts both increase. For a first version, saving still images is the more practical approach.

What should I keep in mind for real-world use?

A few recommendations:

Use Raspberry Pi OS 64-bit
Prefer an SSD over microSD for storage
Start with image saving only
Check both the Home Assistant logs and the eufy-security-ws logs when troubleshooting
Do not forget the notification settings in the Eufy app

Summary

It is entirely possible to use a Raspberry Pi 4 with Raspberry Pi OS and Docker to build a setup where Home Assistant receives pet-detection events from a Eufy IndoorCam 2K Pan & Tilt and saves an image automatically.

The three most important pieces are:

Run Home Assistant as a container
Use eufy-security-ws + eufy_security for the Eufy integration
Save the image by calling image.snapshot on the Event Image

The initial setup can be slightly tricky around HACS, authentication settings, and reloading automations.yaml, but once those are in place, the overall system is fairly straightforward.

For a Raspberry Pi 4, this is a practical and realistic setup if your goal is simply to save a still image whenever your pet is detected.

Editing Privileged Files from Emacs: Two Practical Approaches

vast cow — Thu, 23 Apr 2026 07:47:25 +0000

If you use Emacs with a user-owned daemon and emacsclient, editing privileged files can become awkward.

At first glance, sudo -e (sudoedit) looks like the right tool. It is safer than running your editor directly as root, and it integrates cleanly with the usual EDITOR/VISUAL environment variables. But recent versions of sudo are deliberately conservative. In particular, sudoedit may refuse to edit a file if it lives in a directory that is writable by the calling user. That behavior comes from the sudoers policy option sudoedit_checkdir.

In practice, there are two reasonable ways to deal with this:

Adjust sudoers so that sudoedit allows the workflow you want.
Skip sudoedit entirely and open the file through Emacs TRAMP with /sudo::.

This article walks through both approaches and explains when each one makes sense.

Why `sudoedit` blocks some files

sudoedit does not normally run your editor as root on the target file itself. Instead, it copies the file to a temporary location, launches your editor as your normal user, and then copies the modified contents back into place afterward.

That design is intentional. It reduces the risk of running a full interactive editor with elevated privileges.

On top of that, sudoedit includes some additional safety checks. One of them is controlled by sudoedit_checkdir. When that option is enabled, sudoedit refuses to edit files in directories that are writable by the invoking user. The point is to make certain classes of path manipulation and link attacks harder.

That is why a command that looks perfectly reasonable can still fail:

sudoedit some/file

If the parent directory is writable by you, sudoedit may reject it even though you technically have permission to create or modify files there.

Approach 1: Change `sudoers` and keep using `sudoedit`

If you want to preserve the sudoedit model, the direct fix is to adjust sudoers.

The setting that matters

The relevant option is:

Defaults !sudoedit_checkdir

Disabling it tells sudoedit not to reject files merely because they are under a user-writable directory.

How to edit `sudoers` safely

Do not edit /etc/sudoers directly in a normal editor. Use visudo, which performs syntax checking and helps prevent lockouts caused by malformed configuration.

For a system-wide change:

sudo visudo

Then add:

Defaults !sudoedit_checkdir

If you want the change to apply only to a specific user:

Defaults:yourname !sudoedit_checkdir

A cleaner pattern is to place the override in a separate file under /etc/sudoers.d/:

sudo visudo -f /etc/sudoers.d/sudoedit

Then add:

Defaults:yourname !sudoedit_checkdir

That keeps the main sudoers file simpler and makes the change easier to audit later.

Using `sudoedit` with `emacsclient`

Once sudoedit is allowed to do what you want, it works fine with a user-owned Emacs daemon.

For a graphical frame:

export SUDO_EDITOR='emacsclient -c'
sudoedit /etc/hosts

For terminal use:

export SUDO_EDITOR='emacsclient -t'
sudoedit /etc/hosts

This is often the cleanest setup if you like the sudoedit model and want to keep using it.

Pros

Preserves the intended sudoedit workflow
Works naturally with emacsclient
Keeps the editor itself running as your normal user

Cons

Weakens one of sudoedit’s built-in safety checks
Requires administrative access to change policy
Affects host policy, not just your personal workflow

Approach 2: Use Emacs TRAMP with `/sudo::`

If your real goal is simply “open this file from my existing Emacs daemon, with privilege escalation when needed,” then TRAMP is often the more practical answer.

You can open a privileged local file like this:

emacsclient /sudo::/etc/hosts

Or from inside Emacs:

C-x C-f /sudo::/etc/hosts

This uses TRAMP’s sudo method. From the user’s perspective, it feels like opening a normal file, except TRAMP arranges access through sudo.

Why this avoids the `sudoedit` problem

Because this is not sudoedit.

That distinction matters. sudoedit_checkdir is a sudoedit-specific policy control. TRAMP /sudo:: uses sudo, not sudoedit, so it is not subject to that particular check.

This does not mean TRAMP bypasses sudoers entirely. It still relies on sudo, so normal authentication and authorization rules still apply. If your sudoers configuration forbids the underlying access, TRAMP will not magically override that.

But if your problem is specifically the extra sudoedit directory check, /sudo:: is a practical way around it.

Pros

No need to modify sudoers
Fits naturally into an Emacs daemon + emacsclient workflow
Avoids sudoedit_checkdir
Feels seamless once you are already living inside Emacs

Cons

This is not the same security model as sudoedit
You are editing through TRAMP’s sudo method, not through a temporary copy-and-replace flow
Some people prefer sudoedit precisely because it is more restrictive

What about TRAMP `/sudoedit::`?

TRAMP also has a sudoedit method:

emacsclient /sudoedit::/etc/hosts

That is a different thing from /sudo::.

If /sudo:: is the “just let me open the file with elevated access” option, /sudoedit:: is the “stay closer to the sudoedit safety model” option. It is designed to behave more like sudoedit, which also means it is less attractive if your entire goal is to escape sudoedit-specific restrictions.

So the practical distinction is:

Use /sudo:: when you want convenience and a smooth Emacs workflow.
Use /sudoedit:: when you explicitly want sudoedit-style behavior inside TRAMP.

Can you use relative paths with TRAMP?

Yes, but the answer is slightly subtle.

In Emacs, relative paths are resolved against default-directory. That is true for TRAMP too.

So if your current buffer or Dired session is already in:

/sudo::/etc/

then opening:

hosts

will resolve to:

/sudo::/etc/hosts

In other words, relative paths work perfectly well once your current directory is already a TRAMP path.

A common pattern is:

C-x C-f /sudo::/etc/

and then from there, open files such as hosts, fstab, or ssh/sshd_config relative to that directory.

From a shell, though, it is usually simpler to pass a full TRAMP path to emacsclient rather than relying on implicit context.

Which approach should you choose?

The answer depends on what you are optimizing for.

Choose `sudoers` + `sudoedit` if:

you want to keep the sudoedit workflow
you prefer its temporary-file model
you are comfortable changing system policy
you want emacsclient to act purely as the editor frontend for sudoedit

Choose TRAMP `/sudo::` if:

you already use a user-owned emacs -daemon
you want emacsclient to open privileged files directly and naturally
you do not want to touch sudoers
your main frustration is specifically sudoedit_checkdir

In day-to-day Emacs usage, /sudo:: is usually the more ergonomic solution. It integrates better with how Emacs users actually work. By contrast, changing sudoers is more appropriate when you explicitly want to preserve the sudoedit model across the machine.

A minimal practical setup

If you want the simplest workable arrangement, this is often enough:

alias ec='emacsclient -c'

Then open privileged files through TRAMP when needed:

ec /sudo::/etc/hosts

If you still want to keep sudoedit available as well:

export SUDO_EDITOR='emacsclient -c'

That gives you both options:

sudoedit /path/to/file when you want the sudoedit model
emacsclient /sudo::/path/to/file when you want the most direct Emacs workflow

Final thoughts

There is no single universally correct answer here, because the two approaches serve slightly different goals.

Changing sudoers is the right move if you want to preserve sudoedit and simply relax one of its checks.

Using TRAMP /sudo:: is the right move if your real priority is editing privileged files comfortably from an existing Emacs daemon without fighting sudoedit’s policy decisions.

If you are an Emacs-heavy user, the second option is often the one that feels more natural in practice. If you are managing system policy for a shared host, the first option may be the more disciplined choice.

How to Automatically Post Eufy Detection Images to Slack from Home Assistant

vast cow — Thu, 23 Apr 2026 07:25:35 +0000

If you already have Eufy integrated with Home Assistant and can access the camera’s event image, the next step is straightforward: save that image and send it to a Slack channel automatically.

This article assumes the following is already in place:

Eufy is connected to Home Assistant
The camera exposes an image.xxx_event_image entity
Detection-related entities such as binary_sensor.xxx_pet_detected are available if needed
Eufy image retrieval itself is already working

The goal is simple:

Create a Slack app
Add the Slack integration to Home Assistant
Extend your existing automation so it posts the saved image to Slack
Avoid the common configuration mistakes that tend to break file uploads

Step-by-Step Setup

1. Understand the overall flow

At a high level, the automation looks like this:

Eufy event image updates
  → Home Assistant automation runs
  → Image is saved to /media/eufy_snapshots
  → The saved image is uploaded to Slack

Since image retrieval is already working, the only new part is the Slack side.
Your existing setup already covers the image snapshot flow and local storage under /media/eufy_snapshots.

2. Create a Slack app

To let Home Assistant post messages and upload files, you need a Slack app with a bot user.

Create a new app in the Slack API dashboard and attach it to the workspace where you want notifications to appear.

Then open OAuth & Permissions and configure the bot token scopes.

Recommended bot scopes

If you want both text messages and file attachments to work reliably, add these scopes:

chat:write
chat:write.public
chat:write.customize
files:write
channels:read
groups:read
mpim:read
im:read

Text-only notifications may work with fewer permissions, but file uploads often fail unless the read-related scopes are also present. In this setup, Home Assistant may need to resolve the channel ID before uploading the file.

3. Reinstall the app to the workspace

This step is easy to miss.

After changing scopes, reinstall the Slack app to the workspace so the updated permissions actually take effect. Without reinstalling, the new scopes may not be reflected in the token.

4. Copy the Bot User OAuth Token

Once the app is installed, Slack will issue a Bot User OAuth Token, typically starting with xoxb-.

Keep that token handy. You will use it as the API key in Home Assistant.

5. Invite the bot to the destination channel

If you want to post into a channel such as #pet-camera, make sure the bot has been added to that channel.

For example:

/invite @your-bot-name

If the bot is not in the channel, posting may fail even if the rest of the setup is correct.

6. Add the Slack integration in Home Assistant

Now switch to Home Assistant.

Go to:

Settings
Devices & Services
Add Integration
Slack

When prompted, enter:

API Key
→ the xoxb-... Bot User OAuth Token
Default Channel
→ for example #pet-camera
Username / Icon
→ optional

Once configured, Home Assistant will create a notify service such as notify.xxx, which you will use in your automation.

7. Find the actual `notify.xxx` service name

Do not guess the notify service name.

Open Developer Tools → Actions and type notify. to see the exact service name Home Assistant generated for your Slack workspace.

This matters more than it sounds. If your Slack workspace name includes Japanese or Chinese characters, the resulting notify.xxx service name may not be the romanization you expect. In practice, it can end up looking like a transliterated form you would not guess correctly by hand.

Always verify the real service name in Home Assistant before using it in YAML.

8. Confirm that the snapshot directory is allowlisted

Since you are attaching a local file, Home Assistant must be allowed to access the directory where the image is stored.

Your existing image-save setup already uses this path: /media/eufy_snapshots.

Make sure configuration.yaml includes:

homeassistant:
  allowlist_external_dirs:
    - /media/eufy_snapshots

If you add or change this setting, restart Home Assistant afterward.

9. Test a plain text Slack notification first

Before touching your automation, verify that basic Slack notifications work.

In Developer Tools → Actions, call your Slack notify service with something like:

message: "Test notification"
title: "Home Assistant Test"
target: "#pet-camera"

If this works, authentication and basic Slack delivery are fine.

10. Test a fixed image upload

Next, test file upload with a known file path before introducing templates or variables.

Use a simple payload like this:

message: "Image upload test"
title: "test image"
data:
  file:
    path: /media/eufy_snapshots/test.jpg

At first, it can be helpful to omit target and let the message go to the integration’s default channel. That removes one more variable from the test.

If this succeeds, then the file upload mechanism itself is working.

11. Add Slack upload to your automation

Once the fixed upload test works, extend your existing automation.

Here is a complete example:

alias: Eufy pet detection posts image to Slack
description: ""
triggers:
  - trigger: state
    entity_id:
      - image.living_room_event_image
conditions:
  - condition: state
    entity_id: binary_sensor.living_room_pet_detected
    state:
      - "on"
actions:
  - variables:
      ts: "{{ now().strftime('%Y%m%d-%H%M%S') }}"
      file: /media/eufy_snapshots/pet_{{ ts }}.jpg
  - action: image.snapshot
    metadata: {}
    target:
      entity_id: image.living_room_event_image
    data:
      filename: "{{ file }}"
  - delay:
      hours: 0
      minutes: 0
      seconds: 2
      milliseconds: 0
  - action: notify.YOUR_SLACK_SERVICE
    data:
      message: ""
      data:
        file:
          path: "{{ file }}"

This automation does four things:

Waits for the Eufy event image to update
Checks whether the pet detection sensor is on
Saves the event image to a timestamped JPEG file
Uploads that saved file to Slack

The image-save portion follows the same event image approach already established in the existing Eufy/Home Assistant setup.

12. Reload or restart Home Assistant

If you edited automations.yaml directly, the automation will not become active until you reload automations or restart Home Assistant.

You can either:

Run automation.reload from Developer Tools → Actions
Restart Home Assistant

13. Verify end-to-end behavior

Finally, test the full flow:

Trigger a real detection event
Confirm that binary_sensor.xxx_pet_detected changes to on
Confirm that image.xxx_event_image updates
Confirm that a JPEG appears in /media/eufy_snapshots
Confirm that Slack receives the message with the attached image

To inspect saved files on disk:

ls -lh ~/ha-stack/homeassistant/media/eufy_snapshots

Common Pitfalls and Troubleshooting

File uploads fail, but text messages work

This is one of the most common failure modes.

If plain text Slack messages succeed but file uploads fail, the problem is usually not authentication. It is usually one of these:

missing Slack scopes
missing files:write
missing read scopes for channel resolution
the bot is not in the target channel
the local file path is wrong
the directory is not allowlisted

A particularly common error is missing_scope when Home Assistant tries to resolve the channel ID through Slack. In that case, adding the following scopes usually fixes it:

channels:read
groups:read
mpim:read
im:read

In this setup, adding files:write and reinstalling the app to the workspace resolved the issue.

Do not guess the `notify.xxx` service name

If your Slack workspace name contains Japanese or other non-Latin characters, the generated notify service name may not match what you intuitively expect.

Check the exact name under Developer Tools → Actions rather than typing it from memory.

This avoids a surprisingly frustrating class of errors.

`Message malformed: extra keys not allowed @ data['0']`

This error usually has nothing to do with Slack itself.

It almost always means the YAML structure is wrong for the place where you pasted it.

Typical causes include:

pasting a full automation where only an action payload is expected
pasting a list-based block with a leading - into a single-object YAML editor
mixing up Developer Tools action YAML and full automation YAML

For example, in a single automation editor, this often causes trouble:

- alias: ...
  trigger:
    ...

In that context, the editor usually expects:

alias: ...
trigger:
  ...
condition:
  ...
action:
  ...

Likewise, if you are testing only the Slack call in Developer Tools, use a single action payload rather than a full automation.

Test with a fixed file before using templates

Do not start with the full templated automation if file uploads are failing.

First test with a known-good file path:

message: "Image upload test"
title: "test image"
data:
  file:
    path: /media/eufy_snapshots/test.jpg

Once that works, switch to {{ file }} in the automation.

This makes troubleshooting much easier.

Omit `target` at first if necessary

Channel resolution introduces another possible point of failure.

If uploads are still failing, temporarily remove target and let the Slack integration post to its configured default channel. Once that works, add the explicit target back.

Add a short delay after saving the image

Uploading immediately after saving sometimes creates a race condition, especially on smaller systems.

A short delay like this improves reliability:

- delay:
    seconds: 2

It is a small detail, but it helps.

Final Thoughts

If Eufy event images are already available in Home Assistant, posting them to Slack is a relatively small next step.

The core work is:

create a Slack app
grant the right scopes
connect Slack to Home Assistant
upload the saved event image from your automation

The main things that tend to trip people up are not the automation logic itself, but the surrounding details:

missing Slack scopes for file uploads
unexpected notify.xxx service names
YAML pasted into the wrong place
file path and allowlist issues

Once those are handled, the setup is quite clean: Eufy detection image in, Slack notification out.

How to Make a `textarea` Automatically Grow With Its Content

vast cow — Wed, 22 Apr 2026 14:35:04 +0000

A textarea that expands as the user types makes forms feel much smoother. Instead of forcing users to scroll inside the field, you can adjust its height automatically based on the amount of text.

A simple way to do this is to use JavaScript with scrollHeight.

The idea

The pattern is straightforward:

Reset the height to auto
Set the height to the element’s scrollHeight

function autoResize(textarea) {
  textarea.style.height = "auto";
  textarea.style.height = textarea.scrollHeight + "px";
}

This works because scrollHeight gives you the full height needed to display all of the content without an internal scrollbar.

Run it on input

To keep the height in sync while the user types, call the function on every input event.

const textarea = document.getElementById("message");

textarea.addEventListener("input", () => {
  autoResize(textarea);
});

Recommended CSS

A few CSS rules help this behave cleanly:

textarea {
  width: 100%;
  min-height: 120px;
  resize: none;
  overflow: hidden;
  box-sizing: border-box;
}

resize: none prevents manual dragging, and overflow: hidden avoids showing a scrollbar inside the field.

Minimal example

Here is a complete, reusable version:

<textarea id="message" placeholder="Type here..."></textarea>

<style>
  textarea {
    width: 100%;
    min-height: 120px;
    resize: none;
    overflow: hidden;
    box-sizing: border-box;
  }
</style>

<script>
  const textarea = document.getElementById("message");

  function autoResize(textarea) {
    textarea.style.height = "auto";
    textarea.style.height = textarea.scrollHeight + "px";
  }

  textarea.addEventListener("input", () => {
    autoResize(textarea);
  });

  autoResize(textarea);
</script>

One small detail to remember

If you change the value with JavaScript, the height will not update by itself. After setting textarea.value, call autoResize(textarea) again.

In practice, that is all you need. By combining scrollHeight with a small resize function, you can add an auto-growing textarea to almost any page with minimal code.

Toggle Windows Light and Dark Mode with Python

vast cow — Wed, 22 Apr 2026 13:05:27 +0000

Switching between light and dark mode on Windows usually requires going through the Settings app. This small Python script simplifies the process by letting you toggle the theme instantly. It works by updating system settings directly and notifying Windows to apply the change right away.

Purpose

This script is designed to make theme switching quick and automatable. It can be useful in scenarios such as:

Quickly toggling themes with a single command
Integrating theme changes into automation scripts
Setting up time-based switching (e.g., dark mode at night)

How It Works

The script performs two main actions:

1. Modify Windows Registry Settings

Windows stores theme preferences in the user registry. The script updates two values:

AppsUseLightTheme (controls app appearance)
SystemUsesLightTheme (controls system UI appearance)

By setting these values to 1 (light) or 0 (dark), the theme preference is changed.

2. Notify the System

After updating the registry, the script sends a system-wide message to inform Windows that the theme has changed. Without this step, the UI would not update immediately.

Key Functions

Get the Current Theme

get_current_theme()

Returns the current theme setting:

1 → Light mode
0 → Dark mode

Set a Specific Theme

set_theme(light: bool)

Sets the theme explicitly:

True → Light mode
False → Dark mode

Toggle the Theme

toggle_theme()

Switches the current theme to the opposite state.
If the system is in light mode, it changes to dark mode, and vice versa.

Usage

Run the Script

Simply execute the script:

python script.py

Each time it runs, it toggles the current theme and prints the result:

Light mode
Dark mode

Practical Use Cases

Assign it to a desktop shortcut for quick access
Combine it with Task Scheduler for automatic switching
Integrate it into custom productivity workflows

Notes

This script is intended for Windows only
It modifies the user registry, so appropriate permissions may be required
Some applications may not reflect the change immediately

Summary

This approach provides a straightforward way to control Windows appearance settings programmatically. By wrapping registry updates and system notifications into a simple script, it enables fast and flexible theme switching without relying on manual configuration.

import ctypes 
from ctypes import wintypes 
import winreg 


PERSONALIZE_KEY = "Software\\Microsoft\\Windows\\CurrentVersion\\Themes\\Personalize" 
APPS_KEY = "AppsUseLightTheme" 
SYSTEM_KEY = "SystemUsesLightTheme" 

# Win32 constants 
HWND_BROADCAST = 0xFFFF 
WM_SETTINGCHANGE = 0x001A 
SMTO_ABORTIFHUNG = 0x0002 

# Fallback for environments where ULONG_PTR is missing 
if hasattr(wintypes, "ULONG_PTR"): 
    ULONG_PTR = wintypes.ULONG_PTR 
else: 
    ULONG_PTR = ctypes.c_size_t 


def get_current_theme() -> int: 
    try: 
        with winreg.OpenKey(winreg.HKEY_CURRENT_USER, PERSONALIZE_KEY) as key: 
            value, regtype = winreg.QueryValueEx(key, APPS_KEY) 
            if regtype == winreg.REG_DWORD: 
                return int(value) 
    except FileNotFoundError: 
        pass 
    return 1 


def set_theme(light: bool) -> None: 
    value = 1 if light else 0 

    with winreg.CreateKey(winreg.HKEY_CURRENT_USER, PERSONALIZE_KEY) as key: 
        winreg.SetValueEx(key, APPS_KEY, 0, winreg.REG_DWORD, value) 
        winreg.SetValueEx(key, SYSTEM_KEY, 0, winreg.REG_DWORD, value) 

    notify_theme_changed() 


def toggle_theme() -> bool: 
    current = get_current_theme() 
    new_light = not bool(current) 
    set_theme(new_light) 
    return new_light 


def notify_theme_changed() -> None: 
    user32 = ctypes.WinDLL("user32", use_last_error=True) 

    SendMessageTimeoutW = user32.SendMessageTimeoutW 
    SendMessageTimeoutW.argtypes = [ 
        wintypes.HWND, 
        wintypes.UINT, 
        wintypes.WPARAM, 
        wintypes.LPCWSTR, 
        wintypes.UINT, 
        wintypes.UINT, 
        ctypes.POINTER(ULONG_PTR), 
    ] 
    SendMessageTimeoutW.restype = wintypes.LPARAM 

    result = ULONG_PTR() 
    ret = SendMessageTimeoutW( 
        HWND_BROADCAST, 
        WM_SETTINGCHANGE, 
        0, 
        "ImmersiveColorSet", 
        SMTO_ABORTIFHUNG, 
        5000, 
        ctypes.byref(result), 
    ) 

    if ret == 0: 
        raise ctypes.WinError(ctypes.get_last_error()) 


if __name__ == "__main__": 
    is_light = toggle_theme() 
    print("Light mode" if is_light else "Dark mode")

Preventing `\n` from Entering Codex Prompts

vast cow — Mon, 20 Apr 2026 11:57:47 +0000

When using Codex, unwanted line breaks can sometimes appear in the prompt field. This can make prompts harder to read, edit, and send in a clean format. This script is designed to prevent that problem in ChatGPT Codex Cloud.

What This Script Does

This UserScript watches the prompt input area in Codex Cloud and automatically removes newline characters that appear in the text.

More specifically, it monitors the #prompt-textarea element and cleans up line breaks found in its direct paragraph elements. As a result, prompts stay in a single-line format instead of being split across multiple lines unexpectedly.

The script also tries to preserve the caret position after cleaning the text. This helps keep typing smooth and reduces disruption while editing.

Why Use It

The main purpose of this script is to make prompt entry more stable and easier to manage.

It can be useful when you want to:

avoid accidental line breaks in prompts
keep prompts in a clean, single-line format
reduce editing issues caused by unexpected newlines

From a user perspective, it works as a simple helper that automatically removes unwanted line breaks while you type.

How to Use It

Add It as a UserScript

This code is meant to be used as a UserScript. In practice, that means installing a browser extension that supports UserScripts and then adding this script to it.

Once it is installed, the script runs automatically on the matching Codex Cloud pages.

Supported Pages

The script is set to run on these URLs:

https://chatgpt.com/codex/cloud
https://chatgpt.com/codex/cloud/*

When you open one of these pages, the script starts working automatically.

How It Works in Practice

After the page loads, the script waits for the prompt editor to appear. Once the editor is available, it starts listening for input changes.

Each time you type, the script checks whether newline characters have appeared in the prompt. If they have, it removes them and then restores the caret as naturally as possible.

Things to Keep in Mind

It Is Best for Single-Line Prompts

Because this script removes line breaks, it is best suited for workflows where prompts are meant to stay on one line. It is not a good fit if you intentionally want to write multi-line prompts.

It Helps Keep Input Clean

This script is especially useful for people who want a simpler, cleaner prompt field and do not want formatting problems caused by unexpected newlines.

Conclusion

This UserScript is a simple way to prevent unwanted newlines in Codex Cloud prompts. It watches the input field, removes line breaks automatically, and keeps the caret position as stable as possible.

You do not need to understand the internal implementation in detail to use it. In practical terms, it is a lightweight tool for keeping Codex prompts clean and easy to edit.

// ==UserScript==
// @name         ChatGPT Codex Cloud - Remove Newlines in Prompt
// @namespace    https://chatgpt.com/
// @version      1.1.2-debug
// @description  Remove CR/LF from direct <p> children on paste event with detailed debug logs.
// @match        https://chatgpt.com/codex/cloud
// @match        https://chatgpt.com/codex/cloud/*
// @grant        none
// ==/UserScript==

(() => {
  "use strict";

  const LOG_PREFIX = "[CodexPromptNLDebug]";
  const SCRIPT_VERSION = "1.1.2-debug";

  let observerA = null; // waits for #prompt-textarea to appear
  let observerB = null; // watches #prompt-textarea replacement/removal
  let currentEditor = null;
  let pasteHandler = null;

  let attachCount = 0;
  let pasteCount = 0;
  let sanitizeCount = 0;
  let observerACallbackCount = 0;
  let observerBCallbackCount = 0;

  function log(...args) {
    console.log(LOG_PREFIX, ...args);
  }

  function warn(...args) {
    console.warn(LOG_PREFIX, ...args);
  }

  function error(...args) {
    console.error(LOG_PREFIX, ...args);
  }

  function describeNode(node) {
    if (!node) return null;

    return {
      nodeName: node.nodeName,
      id: node.id || null,
      className: typeof node.className === "string" ? node.className : null,
      isConnected: node.isConnected,
      childElementCount: node.childElementCount,
      textLength: node.textContent?.length ?? null,
      htmlLength: node.innerHTML?.length ?? null,
    };
  }

  function getEditor() {
    return document.querySelector("#prompt-textarea");
  }

  function getParagraphs(editor = getEditor()) {
    if (!editor) return [];
    return editor.querySelectorAll(":scope > p");
  }

  function sanitizeParagraphs(reason = "unknown") {
    sanitizeCount += 1;

    log("sanitizeParagraphs:start", {
      sanitizeCount,
      reason,
      href: location.href,
      activeElement: describeNode(document.activeElement),
      currentEditor: describeNode(currentEditor),
      foundEditor: describeNode(getEditor()),
    });

    try {
      const editor = getEditor();

      if (!editor) {
        warn("sanitizeParagraphs:editor-not-found", {
          sanitizeCount,
          reason,
        });
        return;
      }

      const paragraphs = getParagraphs(editor);

      log("sanitizeParagraphs:editor-found", {
        sanitizeCount,
        reason,
        editor: describeNode(editor),
        paragraphCount: paragraphs.length,
      });

      let changedCount = 0;

      paragraphs.forEach((p, index) => {
        const before = p.innerHTML;
        const after = before.replaceAll("\r", "").replaceAll("\n", "");

        const hasCR = before.includes("\r");
        const hasLF = before.includes("\n");

        log("sanitizeParagraphs:paragraph-check", {
          sanitizeCount,
          index,
          hasCR,
          hasLF,
          beforeHtmlLength: before.length,
          afterHtmlLength: after.length,
          textLength: p.textContent?.length ?? null,
        });

        if (before !== after) {
          changedCount += 1;

          log("sanitizeParagraphs:paragraph-changed", {
            sanitizeCount,
            index,
            before,
            after,
          });

          p.innerHTML = after;
        } else {
          log("sanitizeParagraphs:paragraph-unchanged", {
            sanitizeCount,
            index,
          });
        }
      });

      log("sanitizeParagraphs:done", {
        sanitizeCount,
        reason,
        paragraphCount: paragraphs.length,
        changedCount,
      });
    } catch (err) {
      error("sanitizeParagraphs:error", {
        sanitizeCount,
        reason,
        errorName: err?.name,
        errorMessage: err?.message,
        stack: err?.stack,
      });
    }
  }

  function detachFromCurrentEditor(reason = "unknown") {
    log("detachFromCurrentEditor:start", {
      reason,
      currentEditor: describeNode(currentEditor),
      hasPasteHandler: Boolean(pasteHandler),
    });

    try {
      if (currentEditor && pasteHandler) {
        currentEditor.removeEventListener("paste", pasteHandler);
        log("detachFromCurrentEditor:paste-listener-removed", {
          reason,
        });
      } else {
        log("detachFromCurrentEditor:no-listener-to-remove", {
          reason,
        });
      }
    } catch (err) {
      error("detachFromCurrentEditor:error", {
        reason,
        errorName: err?.name,
        errorMessage: err?.message,
        stack: err?.stack,
      });
    } finally {
      currentEditor = null;
      pasteHandler = null;
    }
  }

  function attachToEditor(editor, reason = "unknown") {
    attachCount += 1;

    log("attachToEditor:start", {
      attachCount,
      reason,
      editor: describeNode(editor),
      sameAsCurrentEditor: editor === currentEditor,
      hasExistingPasteHandler: Boolean(pasteHandler),
      currentEditor: describeNode(currentEditor),
      hasObserverA: Boolean(observerA),
      hasObserverB: Boolean(observerB),
    });

    if (!editor) {
      warn("attachToEditor:called-with-empty-editor", {
        attachCount,
        reason,
      });
      return;
    }

    if (editor === currentEditor && pasteHandler && currentEditor?.isConnected) {
      log("attachToEditor:already-attached-same-connected-editor", {
        attachCount,
        reason,
      });
      return;
    }

    if (currentEditor && pasteHandler) {
      detachFromCurrentEditor("reattach-to-editor");
    }

    currentEditor = editor;

    pasteHandler = (e) => {
      pasteCount += 1;

      log("paste:event-fired", {
        pasteCount,
        eventType: e.type,
        target: describeNode(e.target),
        currentTarget: describeNode(e.currentTarget),
        clipboardTypes: Array.from(e.clipboardData?.types ?? []),
        href: location.href,
      });

      setTimeout(() => {
        log("paste:setTimeout-fired", {
          pasteCount,
          currentEditorConnected: currentEditor?.isConnected ?? null,
          currentEditor: describeNode(currentEditor),
          foundEditor: describeNode(getEditor()),
          paragraphCount: getParagraphs().length,
        });

        sanitizeParagraphs("paste-timeout-0");
      }, 0);
    };

    editor.addEventListener("paste", pasteHandler);

    log("attachToEditor:paste-listener-attached", {
      attachCount,
      reason,
    });

    if (observerA) {
      observerA.disconnect();
      observerA = null;

      log("attachToEditor:observerA-disconnected", {
        attachCount,
        reason,
      });
    }

    ensureObserverB();
  }

  function ensureObserverB() {
    if (observerB) {
      log("ensureObserverB:already-running");
      return;
    }

    observerB = new MutationObserver((mutations) => {
      observerBCallbackCount += 1;

      const foundEditor = getEditor();
      const currentConnected = currentEditor?.isConnected ?? false;
      const sameEditor = foundEditor === currentEditor;

      log("observerB:callback", {
        observerBCallbackCount,
        mutationCount: mutations.length,
        foundEditorExists: Boolean(foundEditor),
        currentConnected,
        sameEditor,
        currentEditor: describeNode(currentEditor),
        foundEditor: describeNode(foundEditor),
      });

      // Case 1:
      // #prompt-textarea が完全に消えた
      if (!foundEditor) {
        log("observerB:editor-not-found", {
          observerBCallbackCount,
        });

        detachFromCurrentEditor("editor-not-found");

        if (observerB) {
          observerB.disconnect();
          observerB = null;

          log("observerB:disconnected", {
            observerBCallbackCount,
          });
        }

        waitForEditor("editor-not-found");
        return;
      }

      // Case 2:
      // 新しい #prompt-textarea が存在するが、currentEditor は古い detached node を指している
      // 今回のログで発生していたのはこのケース
      if (!currentConnected || !sameEditor) {
        warn("observerB:editor-replaced-detected", {
          observerBCallbackCount,
          currentConnected,
          sameEditor,
          currentEditor: describeNode(currentEditor),
          foundEditor: describeNode(foundEditor),
        });

        attachToEditor(foundEditor, "observerB-detected-replacement");
        return;
      }
    });

    observerB.observe(document.documentElement, {
      childList: true,
      subtree: true,
    });

    log("ensureObserverB:started");
  }

  function waitForEditor(reason = "initial") {
    log("waitForEditor:start", {
      reason,
      href: location.href,
      readyState: document.readyState,
      hasObserverA: Boolean(observerA),
      hasObserverB: Boolean(observerB),
      currentEditor: describeNode(currentEditor),
    });

    const editor = getEditor();

    if (editor) {
      log("waitForEditor:editor-already-present", {
        reason,
        editor: describeNode(editor),
      });

      attachToEditor(editor, `waitForEditor:${reason}`);
      return;
    }

    if (observerA) {
      log("waitForEditor:observerA-already-running", {
        reason,
      });
      return;
    }

    observerA = new MutationObserver((mutations) => {
      observerACallbackCount += 1;

      const found = getEditor();

      log("observerA:callback", {
        observerACallbackCount,
        mutationCount: mutations.length,
        found: Boolean(found),
        foundEditor: describeNode(found),
      });

      if (found) {
        log("observerA:editor-appeared", {
          observerACallbackCount,
        });

        attachToEditor(found, "observerA-editor-appeared");
      }
    });

    observerA.observe(document.documentElement, {
      childList: true,
      subtree: true,
    });

    log("waitForEditor:observerA-started", {
      reason,
    });
  }

  log("userscript:initialized", {
    version: SCRIPT_VERSION,
    href: location.href,
    readyState: document.readyState,
    userAgent: navigator.userAgent,
  });

  waitForEditor("initial");
})();

White Background Color Scheme for Windows Terminal

vast cow — Mon, 20 Apr 2026 09:22:01 +0000

Overview

Windows Terminal allows you to customize its appearance through color schemes, improving both readability and overall usability. This article introduces a simple white background color scheme and explains its purpose and how to apply it.

This scheme uses a light background combined with muted text colors, making it suitable for extended use without excessive eye strain.

Purpose of the Color Scheme

A white background color scheme offers several practical advantages:

Improved readability: Dark text stands out clearly against a white background
Visual consistency: Aligns well with common applications like editors and web browsers
Reduced eye fatigue: Less harsh than dark themes in bright environments

It is particularly effective for daytime use or well-lit workspaces.

Key Configuration Points

The provided configuration defines a balanced and minimal color palette:

Background (background): #FFFFFF (white)
Foreground (foreground): #0C0C0C (near-black)
Cursor (cursorColor): Dark color for clear visibility
Selection (selectionBackground): Dark highlight for contrast

Standard terminal colors (red, blue, green, etc.) and their bright variants are also included, ensuring proper color distinction in command outputs.

How to Apply

1. Open the Settings File

Launch Windows Terminal and open the Settings. Edit the configuration file in JSON format.

2. Add the Color Scheme

Insert the following into the "schemes" array:

"schemes": [
    {
        "name": "Theme Name",
        "background": "#FFFFFF",
        "foreground": "#0C0C0C"
        ...
    }
]

If a "schemes" section already exists, simply add this entry to the list.

3. Apply to a Profile

Assign the scheme to a profile (e.g., PowerShell or Command Prompt):

"colorScheme": "Theme Name"

This activates the color scheme for that profile.

Notes

In dark environments, a white background may feel too bright
Some tools rely on specific color assumptions, which may affect visibility

You can fine-tune individual colors as needed to better match your preferences.

Summary

This white background color scheme provides a clean and readable interface for Windows Terminal. It is easy to implement and well-suited for everyday use, especially in bright environments. Adjust it as necessary to create a comfortable and efficient working setup.

{
    "$help": "https://aka.ms/terminal-documentation",
    "$schema": "https://aka.ms/terminal-profiles-schema",
    "schemes": 
    [
        {
            "background": "#FFFFFF",
            "black": "#0C0C0C",
            "blue": "#0037DA",
            "brightBlack": "#767676",
            "brightBlue": "#3B78FF",
            "brightCyan": "#61D6D6",
            "brightGreen": "#16C60C",
            "brightPurple": "#B4009E",
            "brightRed": "#E74856",
            "brightWhite": "#F2F2F2",
            "brightYellow": "#C19C00",
            "cursorColor": "#0C0C0C",
            "cyan": "#3A96DD",
            "foreground": "#0C0C0C",
            "green": "#13A10E",
            "name": "My Light Theme",
            "purple": "#881798",
            "red": "#C50F1F",
            "selectionBackground": "#0C0C0C",
            "white": "#CCCCCC",
            "yellow": "#856B00"
        }
    ]
}

Make PowerShell Readable on a White Windows Terminal Background

vast cow — Mon, 20 Apr 2026 09:16:08 +0000

When you switch Windows Terminal to a light or white background, the default PowerShell token colors can become hard to read. You can fix this by customizing PSReadLine’s color scheme so that prompts, selections, and syntax tokens use higher-contrast tones.

Below is a minimal configuration that keeps most text at the terminal’s default foreground color, uses a dim gray for numbers, and highlights selections in an inverted style. It also gives commands a warm accent for visibility.

# Run in PowerShell (requires PSReadLine)
Import-Module PSReadLine
Set-PSReadLineOption -Colors @{
    ContinuationPrompt = "$([char]0x1b)[39m"      # default foreground
    Default            = "$([char]0x1b)[39m"      # plain text
    Type               = "$([char]0x1b)[39m"      # type names
    Selection          = "$([char]0x1b)[39;49;7m" # inverse (swap fg/bg)
    Command            = "$([char]0x1b)[33m"      # yellow for commands
    Member             = "$([char]0x1b)[39m"      # .member names
    Number             = "$([char]0x1b)[38;5;242m"# ANSI 256-color gray
}

Why these choices?

[39m] default foreground: Lets Windows Terminal’s color scheme control the actual text color, so it stays readable whether the background is light or dark.
[33m] yellow for commands: A standard, high-contrast accent that stands out on white without being harsh.
[38;5;242m] gray for numbers: Uses the 256-color palette to render numbers in a softer gray that remains legible on light backgrounds.
[7m] inverse for selections: Inverts foreground/background so selections “pop” regardless of theme.

How to apply permanently

Open your PowerShell profile:

   notepad $PROFILE

Paste the Set-PSReadLineOption -Colors block into the profile file and save.
Restart the terminal (or run the block once) to apply.

That’s it—now your PowerShell prompt and syntax colors stay crisp and readable even with a white Windows Terminal theme.

Forem: vast cow

How to Check and Configure bcache `discard` and `cache_mode`

Checking and Enabling discard

Checking and Changing cache_mode

Things to Check Before Running These Commands

Summary

Getting ytmusicapi Headers with Headless Chrome

Purpose

What the Script Does

Preparation

How to Use It

Output

Why the User-Agent Is Adjusted

How Matching Works

Notes

Summary

mdadm RAID Recovery Test Helper

Purpose

What It Does

Basic Usage

Fixing Known Disk Positions

Testing Arrays with Missing Disks

Checking the Results

Resuming an Interrupted Run

Safety Notes

Summary

Restoring Hidden Playback Buttons in YouTube Music

Overview

Purpose

How to Use

1. Set Up a User Script Manager

2. Install the Script

3. Open YouTube Music

How It Works (Briefly)

Notes

Summary

Using Raspberry Pi 4, Raspberry Pi OS, and Docker to Connect Home Assistant with a Eufy IndoorCam 2K Pan & Tilt and Save Images When a Pet Is Detected

What this setup does

Conclusion first

Step-by-step setup

1. Prepare Raspberry Pi OS

2. Install Docker

3. Create a working directory

4. Create compose.yaml

5. Allow Home Assistant to write snapshots

6. Install HACS

7. Configure the eufy-security-ws login settings

8. Be careful if your password contains $

9. Install the Eufy Security integration from HACS

10. Check the Eufy app settings

11. Confirm the created entities

12. Create automations.yaml

13. Apply the automation changes

Option 1: Reload automations from the UI

Option 2: Restart Home Assistant

14. Verify that the automation is active

15. Test the full flow

Common questions and troubleshooting

Can this really be done with Raspberry Pi 4, Raspberry Pi OS, and Docker?

Should I append to configuration.yaml or replace it?

HACS does not appear under Add Integration

eufy-security-ws says Missing one of USERNAME or PASSWORD

What if the password contains $?

How can I tell whether automations.yaml has been applied?

Do I need live video streaming too?

What should I keep in mind for real-world use?

Summary

Editing Privileged Files from Emacs: Two Practical Approaches

Why sudoedit blocks some files

Approach 1: Change sudoers and keep using sudoedit

The setting that matters

How to edit sudoers safely

Using sudoedit with emacsclient

Pros

Cons

Approach 2: Use Emacs TRAMP with /sudo::

Why this avoids the sudoedit problem

Pros

Cons

What about TRAMP /sudoedit::?

Checking and Enabling `discard`

Checking and Changing `cache_mode`

4. Create `compose.yaml`

7. Configure the `eufy-security-ws` login settings

8. Be careful if your password contains `$`

12. Create `automations.yaml`

Should I append to `configuration.yaml` or replace it?

`eufy-security-ws` says `Missing one of USERNAME or PASSWORD`

What if the password contains `$`?

How can I tell whether `automations.yaml` has been applied?

Why `sudoedit` blocks some files

Approach 1: Change `sudoers` and keep using `sudoedit`

How to edit `sudoers` safely

Using `sudoedit` with `emacsclient`

Approach 2: Use Emacs TRAMP with `/sudo::`

Why this avoids the `sudoedit` problem

What about TRAMP `/sudoedit::`?

Choose `sudoers` + `sudoedit` if:

Choose TRAMP `/sudo::` if:

7. Find the actual `notify.xxx` service name

Do not guess the `notify.xxx` service name

`Message malformed: extra keys not allowed @ data['0']`

Omit `target` at first if necessary