Skip to content

code-yeongyu/oh-my-openagent / packages/shared-skills/skills/ultimate-browsing

ultimate-browsing

Flagged

Reaches web pages the user's browser cannot open: WAF-blocked and bot-scored hosts, platform-native readers (Chinese and social platforms), archive snapshots with provenance, and a browser you own for stealth or throwaway profiles. Not for plain search, an unblocked static fetch, or a page the user's browser can open.

FileKindSize
.gitignoreother29 B
ATTRIBUTION.mdmarkdown2.5 KB
SKILL.mdskill md11.9 KB
engine/AGENTS.mdmarkdown10.8 KB
engine/__init__.pyscript668 B
engine/__main__.pyscript5.0 KB
engine/bias_check.pyscript7.1 KB
engine/curl_probe.pyscript2.4 KB
engine/executor.pyscript8.0 KB
engine/fetch_chain.pyscript13.0 KB
engine/referers.pyscript327 B
engine/result_schema.pyscript1.5 KB
engine/summary.pyscript1.2 KB
engine/surrogate.pyscript7.9 KB
engine/surrogates.yamlconfig2.3 KB
engine/templates/knip.workspace.jsoncother1.5 KB
engine/templates/package.jsonmanifest349 B
engine/templates/playwright_mobile_chrome.jsscript3.6 KB
engine/templates/playwright_real_chrome.jsscript5.5 KB
engine/tests/fixtures/amp_redirect_stub.htmlother323 B
engine/tests/fixtures/search_interstitial.htmlother90.4 KB
engine/tests/fixtures/wayback_available.jsonconfig246 B
engine/tests/fixtures/wayback_snapshot.htmlother181.4 KB
engine/tests/test_executor_timeout.pyscript6.2 KB
engine/tests/test_fetch_chain.pyscript2.7 KB
engine/tests/test_playwright_stealth.pyscript3.9 KB
engine/tests/test_playwright_templates.pyscript10.7 KB
engine/tests/test_surrogate.pyscript11.3 KB
engine/tests/test_surrogate_validators.pyscript3.5 KB
engine/url_transforms.pyscript3.2 KB
engine/validators.pyscript9.1 KB
engine/waf_detector.pyscript6.9 KB
engine/waf_profiles.yamlconfig6.2 KB
references/agent-reach/README.mdmarkdown2.2 KB
references/agent-reach/career.mdmarkdown755 B
references/agent-reach/dev.mdmarkdown1.3 KB
references/agent-reach/search.mdmarkdown821 B
references/agent-reach/social.mdmarkdown5.6 KB
references/agent-reach/video.mdmarkdown2.7 KB
references/agent-reach/web.mdmarkdown2.1 KB
references/chrome-stealth.mdmarkdown2.4 KB
references/insane-search/README.mdmarkdown20.2 KB
references/insane-search/cache-archive.mdmarkdown4.1 KB
references/insane-search/fallback.mdmarkdown6.9 KB
references/insane-search/jina.mdmarkdown4.3 KB
references/insane-search/json-api.mdmarkdown3.5 KB
references/insane-search/media.mdmarkdown3.5 KB
references/insane-search/metadata.mdmarkdown2.9 KB
references/insane-search/naver.mdmarkdown3.4 KB
references/insane-search/playwright.mdmarkdown6.8 KB
references/insane-search/public-api.mdmarkdown3.4 KB
references/insane-search/rss.mdmarkdown3.0 KB
references/insane-search/tls-impersonate.mdmarkdown6.5 KB
references/insane-search/twitter.mdmarkdown3.5 KB
scripts/cookie_crypto.pyscript2.9 KB
scripts/cookie_domains.pyscript1.1 KB
scripts/cookie_paths.pyscript3.8 KB
scripts/extract_cookies.pyscript9.4 KB
scripts/tests/test_cookie_domain_filter.pyscript3.5 KB
scripts/tests/test_extract_cookies.pyscript9.4 KB

scripts/tests/test_extract_cookies.py

View on GitHub
#!/usr/bin/env python3
"""Synthetic-fixture tests for cross-platform cookie extraction (no live browser)."""
from __future__ import annotations

import shutil
import sqlite3
import sys
import tempfile
import unittest
from pathlib import Path
from typing import Callable
from unittest.mock import patch

sys.path.insert(0, str(Path(__file__).resolve().parent.parent))

from cookie_crypto import decrypt_chromium_value, derive_key  # noqa: E402
from cookie_paths import UnsupportedPlatform, resolve_cookie_db  # noqa: E402
from extract_cookies import extract_cookies, inject_cookies, write_cookie_file  # noqa: E402


def _make_chromium_db(path: Path, name: str, encrypted_value: bytes, host: str) -> None:
    conn = sqlite3.connect(str(path))
    conn.execute(
        "CREATE TABLE cookies (name TEXT, encrypted_value BLOB, host_key TEXT, path TEXT, "
        "expires_utc INTEGER, is_secure INTEGER, is_httponly INTEGER, samesite INTEGER)"
    )
    conn.execute(
        "INSERT INTO cookies VALUES (?,?,?,?,?,?,?,?)",
        (name, encrypted_value, host, "/", 13_300_000_000_000_000, 1, 1, 1),
    )
    conn.commit()
    conn.close()


def _make_firefox_db(path: Path, name: str, value: str, host: str) -> None:
    conn = sqlite3.connect(str(path))
    conn.execute(
        "CREATE TABLE moz_cookies (name TEXT, value TEXT, host TEXT, path TEXT, "
        "expiry INTEGER, isSecure INTEGER, isHttpOnly INTEGER, sameSite INTEGER)"
    )
    conn.execute("INSERT INTO moz_cookies VALUES (?,?,?,?,?,?,?,?)", (name, value, host, "/", 9999999999, 1, 1, 1))
    conn.commit()
    conn.close()


def _encrypt_cbc_v10(key: bytes, plaintext: str) -> bytes:
    from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes

    data = plaintext.encode()
    pad = 16 - (len(data) % 16)
    padded = data + bytes([pad]) * pad
    encryptor = Cipher(algorithms.AES128(key), modes.CBC(b" " * 16)).encryptor()
    return b"v10" + encryptor.update(padded) + encryptor.finalize()


def _encrypt_gcm_v10(key: bytes, plaintext: str) -> bytes:
    from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes

    nonce = b"n" * 12
    encryptor = Cipher(algorithms.AES(key), modes.GCM(nonce)).encryptor()
    ciphertext = encryptor.update(plaintext.encode()) + encryptor.finalize()
    return b"v10" + nonce + ciphertext + encryptor.tag


class PathResolution(unittest.TestCase):
    def test_macos_chromium_path(self) -> None:
        base = Path(self.tmp())
        target = base / "Google/Chrome/Default/Cookies"
        target.parent.mkdir(parents=True)
        target.write_bytes(b"")
        self.assertEqual(resolve_cookie_db("chrome", "darwin", base_override=base), target)

    def test_linux_chromium_network_path(self) -> None:
        base = Path(self.tmp())
        target = base / "google-chrome/Default/Network/Cookies"
        target.parent.mkdir(parents=True)
        target.write_bytes(b"")
        self.assertEqual(resolve_cookie_db("chrome", "linux", base_override=base), target)

    def test_windows_chromium_path(self) -> None:
        base = Path(self.tmp())
        target = base / "Google/Chrome/User Data/Default/Cookies"
        target.parent.mkdir(parents=True)
        target.write_bytes(b"")
        self.assertEqual(resolve_cookie_db("chrome", "win32", base_override=base), target)

    def test_unsupported_platform_raises(self) -> None:
        with self.assertRaises(UnsupportedPlatform):
            resolve_cookie_db("chrome", "sunos")

    def test_unsupported_browser_raises(self) -> None:
        with self.assertRaises(UnsupportedPlatform):
            resolve_cookie_db("nonexistent", "darwin")

    def tmp(self) -> str:
        import tempfile

        d = tempfile.mkdtemp()
        self.addCleanup(lambda: __import__("shutil").rmtree(d, ignore_errors=True))
        return d


class KeyDerivation(unittest.TestCase):
    def test_macos_iters_differ_from_linux(self) -> None:
        secret = b"some-keychain-secret"
        self.assertNotEqual(derive_key("darwin", secret), derive_key("linux", secret))
        self.assertEqual(len(derive_key("darwin", secret)), 16)

    def test_windows_passthrough_32_bytes(self) -> None:
        key = b"k" * 32
        self.assertEqual(derive_key("win32", key), key)

    def test_windows_rejects_wrong_length(self) -> None:
        with self.assertRaises(ValueError):
            derive_key("win32", b"short")

    def test_unsupported_platform_raises(self) -> None:
        with self.assertRaises(UnsupportedPlatform):
            derive_key("sunos", b"x")


class Decryption(unittest.TestCase):
    def test_macos_cbc_roundtrip(self) -> None:
        key = derive_key("darwin", b"secret")
        blob = _encrypt_cbc_v10(key, "session-token-123")
        self.assertEqual(decrypt_chromium_value("darwin", key, blob), "session-token-123")

    def test_windows_gcm_roundtrip(self) -> None:
        key = b"k" * 32
        blob = _encrypt_gcm_v10(key, "win-token-xyz")
        self.assertEqual(decrypt_chromium_value("win32", key, blob), "win-token-xyz")


class EndToEnd(unittest.TestCase):
    def _base_with_db(self, rel: str, make: Callable[[Path], None]) -> Path:
        base = Path(tempfile.mkdtemp())
        self.addCleanup(lambda: shutil.rmtree(str(base), ignore_errors=True))
        db = base / rel
        db.parent.mkdir(parents=True)
        make(db)
        return base

    def test_chromium_extract_with_injected_keyring(self) -> None:
        key = derive_key("darwin", b"secret")
        blob = _encrypt_cbc_v10(key, "logged-in")
        base = self._base_with_db(
            "Google/Chrome/Default/Cookies",
            lambda p: _make_chromium_db(p, "SID", blob, ".youtube.com"),
        )
        cookies = extract_cookies(
            "chrome", ["youtube.com"], platform="darwin",
            keyring_reader=lambda _s: b"secret", base_override=base,
        )
        self.assertEqual(len(cookies), 1)
        self.assertEqual(cookies[0]["value"], "logged-in")
        self.assertEqual(cookies[0]["name"], "SID")

    def test_firefox_extract_unencrypted(self) -> None:
        base = self._base_with_db(
            "Firefox/Profiles/abc.default/cookies.sqlite",
            lambda p: _make_firefox_db(p, "auth", "plain-value", ".example.com"),
        )
        cookies = extract_cookies("firefox", ["example.com"], platform="darwin", base_override=base)
        self.assertEqual(len(cookies), 1)
        self.assertEqual(cookies[0]["value"], "plain-value")


class SecretHandling(unittest.TestCase):
    def test_cookie_output_file_is_owner_only(self) -> None:
        base = Path(tempfile.mkdtemp())
        self.addCleanup(lambda: shutil.rmtree(str(base), ignore_errors=True))
        output = base / "cookies.json"

        write_cookie_file(output, [{"name": "SID", "value": "secret"}])

        self.assertEqual(output.stat().st_mode & 0o777, 0o600)
        self.assertIn("secret", output.read_text())

    def test_cookie_output_replaces_existing_file_only_after_private_temp_write(self) -> None:
        base = Path(tempfile.mkdtemp())
        self.addCleanup(lambda: shutil.rmtree(str(base), ignore_errors=True))
        output = base / "cookies.json"
        output.write_text("old\n")
        output.chmod(0o644)

        def _dump(_cookies, f, indent: int) -> None:
            self.assertEqual(output.read_text(), "old\n")
            self.assertEqual(output.stat().st_mode & 0o777, 0o644)
            temp_files = list(base.glob(".cookies.json.*.tmp"))
            self.assertEqual(len(temp_files), 1)
            self.assertEqual(temp_files[0].stat().st_mode & 0o777, 0o600)
            f.write('[{"name": "SID", "value": "secret"}]')

        with patch("extract_cookies.json.dump", side_effect=_dump):
            write_cookie_file(output, [{"name": "SID", "value": "secret"}])

        self.assertEqual(output.stat().st_mode & 0o777, 0o600)
        self.assertIn("secret", output.read_text())

    def test_cookie_output_refuses_symlinks(self) -> None:
        base = Path(tempfile.mkdtemp())
        self.addCleanup(lambda: shutil.rmtree(str(base), ignore_errors=True))
        target = base / "target.json"
        target.write_text("{}")
        link = base / "cookies.json"
        link.symlink_to(target)

        with self.assertRaises(ValueError):
            write_cookie_file(link, [{"name": "SID", "value": "secret"}])

    def test_cookie_output_refuses_dangling_symlinks(self) -> None:
        base = Path(tempfile.mkdtemp())
        self.addCleanup(lambda: shutil.rmtree(str(base), ignore_errors=True))
        link = base / "cookies.json"
        link.symlink_to(base / "missing.json")

        with self.assertRaises(ValueError):
            write_cookie_file(link, [{"name": "SID", "value": "secret"}])

    def test_inject_cookies_sends_values_over_stdin_not_argv(self) -> None:
        cookie = {
            "name": "SID",
            "value": "secret-token",
            "domain": ".youtube.com",
            "path": "/",
            "expires": 9999999999,
            "secure": True,
            "httpOnly": True,
            "sameSite": "Lax",
        }

        with patch("extract_cookies.subprocess.run") as run:
            run.return_value.returncode = 0
            run.return_value.stdout = "1"
            run.return_value.stderr = ""

            inject_cookies([cookie], 9242)

        command = run.call_args.args[0]
        self.assertNotIn("secret-token", command)
        self.assertIn("secret-token", run.call_args.kwargs["input"])


if __name__ == "__main__":
    unittest.main(verbosity=2)
slack-gif-creatoranthropics/skillsKnowledge and utilities for creating animated GIFs optimized for Slack. Provides constraints, validation tools, and animation concepts. Use when users request animated GIFs for Slack like "make me a GIF of X doing Y for Slack."Stars: 197kUpdated Claude CodeCodexVerifiedInstall
ponytailDietrichGebert/ponytailLazy senior dev mode for any coding task: the smallest change that fully solves it, and a reply a busy human understands in one read.Stars: 194kUpdated Claude CodeCodexVerifiedInstall
ponytail-debtDietrichGebert/ponytailHarvest every shortcut: comment into one debt ledger, so deferrals get tracked instead of forgotten. One-shot report.Stars: 194kUpdated Claude CodeCodexVerifiedInstall
ponytail-debtDietrichGebert/ponytailList every `shortcut:` comment (and older `ponytail:` ones) as a debt ledger. One-shot report, changes nothing. Use for "ponytail debt", "what did ponytail defer", "list the shortcuts", /ponytail-debt.Stars: 194kUpdated Claude CodeCodexVerifiedInstall