clipik 0.1.0__tar.gz

clipik-0.1.0/PKG-INFO

@@ -0,0 +1,85 @@
+Metadata-Version: 2.3
+Name: clipik
+Version: 0.1.0
+Summary: Synchronize clipboard buffer by network
+Requires-Dist: asyncio>=4.0.0
+Requires-Dist: loguru>=0.7.3
+Requires-Dist: pydantic>=2.13.5
+Requires-Dist: typing>=3.10.0.0
+Requires-Dist: websockets>=17.1
+Requires-Dist: zeroconf>=0.151.3
+Requires-Python: >=3.11
+Project-URL: Homepage, https://gitflic.ru/project/kurilka/clipik
+Project-URL: Github, https://github.com/TheWhatis/clipik
+Description-Content-Type: text/markdown
+
+---
+title: CLIPIK
+---
+
+[![Latest Stable](http://img.shields.io/pypi/v/clipik.svg)](https://pypi.org/project/clipik)
+[![Scrutinizer](http://img.shields.io/scrutinizer/g/TheWhatis/clipik.svg)](https://scrutinizer-ci.com/g/TheWhatis/clipik)
+[![License](http://img.shields.io/pypi/l/edges/clipik.svg?refresh=true)](https://pypi.org/project/clipik)
+
+CLIPIK - сервис для реализации общего буфера обмена по локальной сети
+
+# Быстрый старт
+
+``` bash
+pip install clipik
+clipik
+```
+
+или
+
+``` bash
+git clone https://gitflic.ru/project/kurilka/clipik
+cd clipik
+uv pip install -e .
+clipik
+```
+
+# Команды/Работа/Переменные окружения
+
+На данный момент никаких аргументов не принимает, одновременно сервер и
+клиент запускается по команде `clipik`,
+
+Имеются только переменные окружения, за счет которых можно менять
+свойства:
+
+- `CLIPIK_LOG_LEVEL=INFO` - Уровель логирования: INFO, DEBUG, ERROR,
+  CRITICAL …
+- `WAYLAND_DISPLAY` - Если оно установлено, будет использовать wayland
+  clipboard
+- `CLIPIK_PORT=8765` - На каком порту поднять websocket (передача
+  буфера)
+- `CLIPIK_HANDSHAKE_TIMEOUT=7` - Сколько ждать HANDSHAKE при подключении
+
+# Обязательные утилиты (зависимости)
+
+## Linux
+
+### X11 (xorg)
+
+- `xclip`
+- `clipnotify`
+
+### Wayland
+
+- `wl-paste`
+- `wl-copy`
+
+## MacOs (пока не поддерживается)
+
+## Windows (пока не поддерживается)
+
+# <span class="todo TODO">TODO</span> 
+
+- [ ] Возможность регестрировать сервисы для подключения к удаленным
+  сетями
+- [ ] Регистрацию при подключении (ввод pin-кода/разрешенные хосты в
+  конфиге)
+- [ ] Поддержка всех типов данных, в том числе при копировании из
+  файловых менеджеров
+- [ ] Поддержка MacOS
+- [ ] Поддержка Windows

clipik-0.1.0/README.md

@@ -0,0 +1,70 @@
+---
+title: CLIPIK
+---
+
+[![Latest Stable](http://img.shields.io/pypi/v/clipik.svg)](https://pypi.org/project/clipik)
+[![Scrutinizer](http://img.shields.io/scrutinizer/g/TheWhatis/clipik.svg)](https://scrutinizer-ci.com/g/TheWhatis/clipik)
+[![License](http://img.shields.io/pypi/l/edges/clipik.svg?refresh=true)](https://pypi.org/project/clipik)
+
+CLIPIK - сервис для реализации общего буфера обмена по локальной сети
+
+# Быстрый старт
+
+``` bash
+pip install clipik
+clipik
+```
+
+или
+
+``` bash
+git clone https://gitflic.ru/project/kurilka/clipik
+cd clipik
+uv pip install -e .
+clipik
+```
+
+# Команды/Работа/Переменные окружения
+
+На данный момент никаких аргументов не принимает, одновременно сервер и
+клиент запускается по команде `clipik`,
+
+Имеются только переменные окружения, за счет которых можно менять
+свойства:
+
+- `CLIPIK_LOG_LEVEL=INFO` - Уровель логирования: INFO, DEBUG, ERROR,
+  CRITICAL …
+- `WAYLAND_DISPLAY` - Если оно установлено, будет использовать wayland
+  clipboard
+- `CLIPIK_PORT=8765` - На каком порту поднять websocket (передача
+  буфера)
+- `CLIPIK_HANDSHAKE_TIMEOUT=7` - Сколько ждать HANDSHAKE при подключении
+
+# Обязательные утилиты (зависимости)
+
+## Linux
+
+### X11 (xorg)
+
+- `xclip`
+- `clipnotify`
+
+### Wayland
+
+- `wl-paste`
+- `wl-copy`
+
+## MacOs (пока не поддерживается)
+
+## Windows (пока не поддерживается)
+
+# <span class="todo TODO">TODO</span> 
+
+- [ ] Возможность регестрировать сервисы для подключения к удаленным
+  сетями
+- [ ] Регистрацию при подключении (ввод pin-кода/разрешенные хосты в
+  конфиге)
+- [ ] Поддержка всех типов данных, в том числе при копировании из
+  файловых менеджеров
+- [ ] Поддержка MacOS
+- [ ] Поддержка Windows

clipik-0.1.0/pyproject.toml

@@ -0,0 +1,28 @@
+[project]
+name = "clipik"
+version = "0.1.0"
+description = "Synchronize clipboard buffer by network"
+readme = "README.md"
+requires-python = ">=3.11"
+dependencies = [
+    "asyncio>=4.0.0",
+    "loguru>=0.7.3",
+    "pydantic>=2.13.5",
+    "typing>=3.10.0.0",
+    "websockets>=17.1",
+    "zeroconf>=0.151.3",
+]
+
+[project.scripts]
+clipik = "clipik:main"
+
+[project.urls]
+Homepage = "https://gitflic.ru/project/kurilka/clipik"
+Github = "https://github.com/TheWhatis/clipik"
+
+[build-system]
+requires = ["uv_build>=0.12.10,<0.13.0"]
+build-backend = "uv_build"
+
+[dependency-groups]
+dev = ["basedpyright>=1.40.0"]

clipik-0.1.0/pyproject.toml.orig

@@ -0,0 +1,30 @@
+[project]
+name = "clipik"
+version = "0.1.0"
+description = "Synchronize clipboard buffer by network"
+readme = "README.md"
+requires-python = ">=3.11"
+dependencies = [
+    "asyncio>=4.0.0",
+    "loguru>=0.7.3",
+    "pydantic>=2.13.5",
+    "typing>=3.10.0.0",
+    "websockets>=17.1",
+    "zeroconf>=0.151.3",
+]
+
+[project.scripts]
+clipik = "clipik:main"
+
+[build-system]
+requires = ["uv_build>=0.12.10,<0.13.0"]
+build-backend = "uv_build"
+
+[dependency-groups]
+dev = [
+    "basedpyright>=1.40.0",
+]
+
+[project.urls]
+Homepage = "https://gitflic.ru/project/kurilka/clipik"
+Github = "https://github.com/TheWhatis/clipik"

clipik-0.1.0/src/clipik/__init__.py

@@ -0,0 +1,5 @@
+from .cli import main
+
+
+if __name__ == '__main__':
+    main()

clipik-0.1.0/src/clipik/__main__.py

@@ -0,0 +1,5 @@
+from .cli import main
+
+
+if __name__ == '__main__':
+    main()

clipik-0.1.0/src/clipik/cli.py

@@ -0,0 +1,60 @@
+import asyncio
+from clipik.utils import get_skipped_required_utils
+from clipik.zeroconf import register_service, unregister_service, discover_services
+from clipik.variables import GRAPHIC_PROTOCOL
+from clipik.logger import logger
+from clipik.websocket import broadcast_local, connect_to_server, start_websocket_server
+from clipik.model import NewServiceEvent, LoseServiceEvent
+from clipik.exception import InitializationError
+
+if GRAPHIC_PROTOCOL == 'x11':
+    from clipik.clipboard.x11 import set_clipboard, listen_clipboard, is_duplicate_clipboard
+else:
+    from clipik.clipboard.wayland import set_clipboard, listen_clipboard, is_duplicate_clipboard
+
+
+_SERVER_TASKS: dict[str, asyncio.Task] = {}
+
+
+async def _discover():
+    async for event in discover_services():
+        if event.event == 'new_service':
+            _SERVER_TASKS[event.name] = asyncio.create_task(
+                connect_to_server(
+                    host=event.host,
+                    port=event.port,
+                    set_clipboard=set_clipboard,
+                    is_duplicate_clipboard=is_duplicate_clipboard
+                )
+            )
+            continue
+
+        if event.event == 'lose_service' and event.name in _SERVER_TASKS:
+            task = _SERVER_TASKS[event.name]
+            del _SERVER_TASKS[event.name]
+            task.cancel()
+
+
+async def _main():
+    await asyncio.gather(
+        start_websocket_server(set_clipboard, is_duplicate_clipboard),
+        broadcast_local(listen_clipboard),
+        _discover(),
+    )
+
+
+def main():
+    skipped_utils: list[str] = get_skipped_required_utils()
+
+    if skipped_utils:
+        skipped_utils_str: str = ', '.join(skipped_utils)
+        raise InitializationError(f'Utils [{skipped_utils_str}] is required, install it')
+
+    try:
+        register_service()
+        asyncio.run(_main())
+    except Exception as e:
+        logger.critical('Error while asyncio.run: [{}]', e)
+        raise e
+    finally:
+        unregister_service()

clipik-0.1.0/src/clipik/clipboard/wayland.py

@@ -0,0 +1,144 @@
+import asyncio
+from asyncio.subprocess import Process
+import base64
+from collections.abc import AsyncGenerator
+from clipik.model import ClipboardContent
+from clipik.logger import logger
+
+
+async def _get_types() -> list[str]:
+    proc = await asyncio.create_subprocess_exec(
+        'wl-paste', '--list-types',
+        stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.PIPE,
+    )
+
+    stdout, stderr = await proc.communicate()
+
+    if stderr:
+        logger.warning('wayland: wl-paste --list-types stderr: [{}]', stderr.decode)
+
+    return stdout.decode(errors='replace').split()
+
+
+async def _read_data(mime: str) -> bytes:
+    proc = await asyncio.create_subprocess_exec(
+        'wl-paste', '--type', mime,
+        stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.PIPE,
+    )
+
+    stdout, stderr = await proc.communicate()
+
+    if stderr:
+        logger.warning('wayland: wl-paste --type () stderr: [{}]', mime, stderr.decode())
+
+    return stdout
+
+
+async def _write_data(mime, str, data: bytes):
+    try:
+        proc = await asyncio.create_subprocess_exec(
+            'wl-copy', '--type', mime,
+            stdin=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+        )
+
+        _, stderr = await proc.communicate(data)
+
+        if stderr:
+            logger.warning('wayland: wl-copy --type {} stderr: [{}]', mime, stderr.decode())
+    except Exception as e:
+        logger.error('wayland: failed to write data', e)
+
+
+async def _process_watch() -> Process:
+    while True:
+        try:
+            return await asyncio.create_subprocess_exec(
+                'wl-paste', '--watch', 'sh', '-c', 'base64 -w0; echo',
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.DEVNULL,
+            )
+        except Exception as e:
+            logger.error('wayland: failed to start wl-paste --watch: [{}]', e)
+            continue
+
+
+async def listen_clipboard() -> AsyncGenerator[ClipboardContent, None]:
+    logger.debug('Started listen_clipboard wayland')
+    process = await _process_watch()
+
+    while True:
+        try:
+            try:
+                line = await process.stdout.readline()
+            except Exception as e:
+                logger.error('wayland: readline failed: [{}]', e)
+                continue
+        except Exception as e:
+            logger.error('wayland: wl-paste --watch read error: [{}]', e)
+
+        logger.debug('wayland: wl-paste watch line: [{}]', line)
+        if not line and process.returncode is not None:
+            logger.error('wayland: wl-paste --watch exited with code [{}]', process.returncode)
+            continue
+
+        try:
+            types: list[str] = await _get_types()
+        except Exception as e:
+            logger.error('wayland: failed to get types [{}]', e)
+            continue
+
+        logger.debug('Get types for clipboard: [{}]', types)
+        if not types:
+            logger.warning('wayland: no types available')
+            continue
+
+        preferred: list[str] = [
+            'image/png',
+            'image/jpeg',
+            'image/bmp',
+            'text/plain',
+            'text/html',
+        ]
+
+        chosen: str = next((p for p in preferred if p in types), types[0])
+
+        try:
+            raw: bytes = await _read_data(chosen)
+        except Exception as e:
+            logger.error('wayland: failed to read [{}]: [{}]', chosen, e)
+            continue
+
+        yield ClipboardContent(
+            mime=chosen,
+            data=base64.b64encode(raw).decode()
+        )
+
+
+async def set_clipboard(content: ClipboardContent):
+    if not content.data:
+        return
+
+    raw: bytes = content.data
+
+    if isinstance(content.data, str):
+        raw = base64.b64decode(content.data)
+
+    await _write_data(content.mime, raw)
+
+
+async def is_duplicate_clipboard(content: ClipboardContent) -> bool:
+    """Проверяет, что переданное содержимое уже находится в буфере обмена."""
+    if not content.data:
+        return False
+
+    types: list[str] = await _get_types()
+    if content.mime not in types:
+        return False
+
+    raw: bytes = await _read_data(content.mime)
+    current_b64: str = base64.b64encode(raw).decode()
+
+    return current_b64 == content.data

clipik-0.1.0/src/clipik/clipboard/x11.py

@@ -0,0 +1,114 @@
+import asyncio
+import base64
+import subprocess
+from collections.abc import AsyncGenerator
+from clipik.model import ClipboardContent
+
+
+async def listen_clipboard() -> AsyncGenerator[ClipboardContent, None]:
+    while True:
+        try:
+            await asyncio.to_thread(subprocess.run, ['clipnotify'], check=True)
+        except subprocess.CalledProcessError as e:
+            logger.error('x11: clipnotify failed: [{}]', e)
+            await asyncio.sleep(0.1)
+            continue
+
+        try:
+            result = await asyncio.to_thread(
+                subprocess.run,
+                ['xclip', '-o', '-selection', 'clipboard', '-t', 'targetse'],
+                capture_output=True,
+                text=True,
+            )
+
+            targets: list[str] = result.stdout.strip().split()
+        except Exception as e:
+            logger.error('x11: failed to get targets: [{}]', e)
+            await asyncio.sleep(0.1)
+            continue
+
+        if not targets:
+            yield ClipboardContent(mime='text/plain', data='')
+            continue
+
+        preferred: list[str] = [
+            'mage/png'
+            'mage/jpeg'
+            'mage/bmp'
+            'ext/plain'
+            'TF8_STRING'
+            'TRING'
+        ]
+
+        chosen: str = next((p for p in preferred if p in targets), targets[0])
+
+        try:
+            raw: bytes = await asyncio.to_thread(
+                lambda: subprocess.run(
+                    ['xclip', '-o', '-selection', 'clipboard', '-t', chosen],
+                    capture_output=True
+                ).stdout
+            )
+        except Exception as e:
+            logger.error('x11: failed to read clipboard: [{}]', e)
+            continue
+
+        yield ClipboardContent(
+            mime=chosen,
+            data=base64.b64encode(raw).decode(),
+        )
+
+
+async def set_clipboard(content: ClipboardContent):
+    if not content.data:
+        return
+
+    try:
+        raw: bytes = content.data
+
+        if isinstance(content.data, str):
+            raw = base64.b64decode(content.data)
+
+        await asyncio.to_thread(
+            subprocess.run,
+            ['xclip', '-selection', 'clipboard', '-t', content.mime],
+            input=raw,
+        )
+    except Exception as e:
+        logger.error('x11: failed to set clipboard: [{}]', e)
+
+
+async def is_duplicate_clipboard(content: ClipboardContent) -> bool:
+    """Проверяет, что переданное содержимое уже находится в буфере обмена."""
+    if not content.data:
+        return False
+
+    try:
+        result = await asyncio.to_thread(
+            subprocess.run,
+            ['xclip', '-o', '-selection', 'clipboard', '-t', 'TARGETS'],
+            capture_output=True,
+            text=True,
+        )
+        targets: list[str] = result.stdout.strip().split()
+    except Exception as e:
+        logger.error('x11: failed to get targets: [{}]', e)
+        return False
+
+    if content.mime not in targets:
+        return False
+
+    try:
+        raw: bytes = await asyncio.to_thread(
+            lambda: subprocess.run(
+                ['xclip', '-o', '-selection', 'clipboard', '-t', content.mime],
+                capture_output=True
+            ).stdout
+        )
+    except Exception as e:
+        logger.error('x11: failed to read clipboard: [{}]', e)
+        return False
+
+    current_b64: str = base64.b64encode(raw).decode()
+    return current_b64 == content.data

clipik-0.1.0/src/clipik/exception.py

@@ -0,0 +1,2 @@
+class InitializationError(Exception):
+    pass

clipik-0.1.0/src/clipik/logger.py

@@ -0,0 +1,35 @@
+import os
+import sys
+from datetime import datetime
+from pathlib import Path
+from loguru import logger
+
+
+_level = os.getenv('CLIPIK_LOG_LEVEL', 'INFO')
+
+
+if os.name == 'nt': # Windows
+    _base_dir = Path(os.getenv('APPDATA', '~'))
+elif sys.platform == 'darwin': # macOS
+    _base_dir = Path.home() / 'Library' / 'Application Support'
+else: # Linux / Unix
+    xdg = os.getenv('XDG_DATA_HOME')
+
+    if xdg:
+        _base_dir = Path(xdg) / 'clipik'
+    else:
+        _base_dir = Path.home() / '.local' / 'share'
+
+
+_base_dir = _base_dir / 'clipik'
+_base_dir.mkdir(parents=True, exist_ok=True)
+
+_filename = datetime.now().strftime('%Y-%m-%d') + '.log'
+_filepath = _base_dir / _filename
+
+
+logger.remove()
+logger.add(str(_filepath), level=_level, encoding='utf-8', rotation='10mb', compression='gz')
+logger.add(sys.stdout, level=_level, colorize=True)
+
+logger.info('ENV LOG_LEVEL: [{}]', _level)

clipik-0.1.0/src/clipik/model.py

@@ -0,0 +1,42 @@
+from typing import Literal
+from pydantic import BaseModel
+from clipik.variables import VERSION, PROTOCOL
+
+
+class ClipboardContent(BaseModel):
+    mime: str
+    data: str | bytes
+
+
+class HandshakeEvent(BaseModel):
+    event: Literal['handshake'] = 'handshake'
+    protocol: str = PROTOCOL
+    version: str = VERSION
+
+
+class HandshakeAckEvent(BaseModel):
+    event: Literal['handshake_ack'] = 'handshake_ack'
+    protocol: str = PROTOCOL
+    version: str = VERSION
+
+
+class ClipboardEvent(BaseModel):
+    event: Literal['clipboard'] = 'clipboard'
+    mime: str
+    data: str
+
+
+class NewServiceEvent(BaseModel):
+    event: Literal['new_service'] = 'new_service'
+    name: str
+    ip: str
+    host: str
+    port: int
+
+
+class LoseServiceEvent(BaseModel):
+    event: Literal['lose_service'] = 'lose_service'
+    name: str
+    ip: str
+    host: str
+    port: int

clipik-0.1.0/src/clipik/utils.py

@@ -0,0 +1,13 @@
+import shutil
+import os
+from clipik.variables import REQUIRED_UTILS
+
+
+def get_skipped_required_utils() -> list[str]:
+    skipped_utils: list[str] = []
+
+    for util in REQUIRED_UTILS:
+        if shutil.which(util) is None:
+            skipped_utils.append(util)
+
+    return skipped_utils

clipik-0.1.0/src/clipik/variables.py

@@ -0,0 +1,34 @@
+import os
+from clipik.logger import logger
+
+
+PROTOCOL = 'CLIPIK'
+VERSION = '0.0.1'
+GRAPHIC_PROTOCOL = 'x11'
+
+if os.getenv('WAYLAND_DISPLAY'):
+    GRAPHIC_PROTOCOL = 'wayland'
+
+
+logger.info('GRAPHIC_PROTOCOL is [{}]', GRAPHIC_PROTOCOL)
+
+
+PEER_PORT = os.getenv('CLIPIK_PORT', default=8765)
+PEER_PORT = int(PEER_PORT)
+
+
+logger.info('PORT: [{}]', PEER_PORT)
+
+
+REQUIRED_UTILS: list[str] = []
+
+if GRAPHIC_PROTOCOL == 'wayland':
+    REQUIRED_UTILS = REQUIRED_UTILS + [
+        'wl-paste',
+        'wl-copy',
+    ]
+else:
+    REQUIRED_UTILS = REQUIRED_UTILS + [
+        'xclip',
+        'clipnotify'
+    ]

clipik-0.1.0/src/clipik/websocket.py

@@ -0,0 +1,147 @@
+import os
+import asyncio
+from collections.abc import Callable, Awaitable, AsyncGenerator
+import websockets
+from typing import TypeAlias
+from websockets.asyncio.server import ServerConnection
+from clipik.logger import logger
+from clipik.variables import PROTOCOL, PEER_PORT
+from clipik.model import (
+    ClipboardContent,
+    HandshakeEvent,
+    HandshakeAckEvent,
+    ClipboardEvent,
+)
+
+
+SetClipboardFn: TypeAlias = Callable[[ClipboardContent], Awaitable[None]]
+ListenClipboardFn: TypeAlias = Callable[[], AsyncGenerator[ClipboardContent, None]]
+IsDuplicateClipboardFn: TypeAlias = Callable[[ClipboardContent], Awaitable[bool]]
+
+
+_HANDSHAKE_TIMEOUT = os.getenv('CLIPIK_HANDSHAKE_TIMEOUT', default=7)
+_HANDSHAKE_TIMEOUT = int(_HANDSHAKE_TIMEOUT)
+_CLIENTS = set()
+
+
+async def _ws_handler(websocket: ServerConnection, set_clipboard: SetClipboardFn, is_duplicate_clipboard: IsDuplicateClipboardFn):
+    try:
+        msg = await asyncio.wait_for(websocket.recv(), timeout=_HANDSHAKE_TIMEOUT)
+
+        try:
+            event = HandshakeEvent.model_validate_json(raw)
+        except Exception as e:
+            logger.warning('Invalid handshake [{}]', msg)
+            await websocket.close(code=1000, reason='Invalid handshake')
+            return
+
+        if event.protocol != PROTOCOL:
+            logger.warning('Invalid handshake protocol [{}]', event.protocol)
+            await websocket.close(code=1000, reason='Invalid handshake')
+            return
+
+        await websocket.send(HandshakeAckEvent().model_dump_json())
+    except Exception as e:
+        logger.warning('Handshake failed: [{}]', e)
+
+    _CLIENTS.add(websocket)
+    peer = websocket.remote_address[0]
+    logger.info('Client connected: [{}]', peer)
+
+    try:
+        async for msg in websocket:
+            try:
+                event = ClipboardEvent.model_validate_json(raw)
+
+                content = ClipboardContent(
+                    mime=payload.get('mime', default='text/plain'),
+                    data=payload.get('data', default=''),
+                )
+
+                logger.debug('Seting clipboard from [{}]: [{}]', peer, content.mime)
+                if await is_duplicate_clipboard(content):
+                    logger.debug('Clipboard from [{}] is duplicate: [{}]', peer, content.mime)
+                    continue
+
+                await set_clipboard(content)
+                logger.debug('Set clipboard from [{}]: [{}]', peer, content.mime)
+            except Exception as e:
+                logger.error('Error listen peer [{}]: [{}]', peer, e)
+    except websockets.exceptions.ConnectionClosed:
+        logger.info('Client disconnected: [{}]', peer)
+    finally:
+        clients.remove(websocket)
+
+
+async def start_websocket_server(
+    set_clipboard: SetClipboardFn,
+    is_duplicate_clipboard: IsDuplicateClipboardFn
+):
+    async def handler(websocket: ServerConnection):
+        await _ws_handler(websocket, set_clipboard, is_duplicate_clipboard)
+
+    async with websockets.serve(handler, '0.0.0.0', PEER_PORT):
+        logger.info('Websocket server started on [{}]', PEER_PORT)
+        await asyncio.Future()
+
+
+async def broadcast_local(listen_clipboard: ListenClipboardFn):
+    async for content in listen_clipboard():
+        if not content.data:
+            continue
+
+        event = ClipboardEvent(
+            mime=content.mime,
+            data=content.data if isinstance(content.data, str) else content.data,
+        )
+
+        payload = event.model_dump_json()
+
+        try:
+            if _CLIENTS:
+                await asyncio.gather(
+                    *[c.send(json.dumps(payload)) for c in _CLIENTS],
+                    return_exceptions=True
+                )
+
+                logger.debug('Broadcasted to [{}] clients', len(_CLIENTS))
+        except Exception as e:
+            logger.error('Error broadcasting to [{}] clients, mime [{}]', len(_CLIENTS), content.mime)
+
+
+async def connect_to_server(host: str, port: int, set_clipboard: SetClipboardFn, is_duplicate_clipboard: IsDuplicateClipboardFn):
+    url = f"ws://{host}:{port}"
+
+    try:
+        async with websockets.connect(url) as ws:
+            await ws.send(HandshakeEvent().model_dump_json())
+
+            raw = await asyncio.wait_for(wc.recv(), timeout=_HANDSHAKE_TIMEOUT)
+            ack = HandshakeAckEvent.model_validate_json(raw)
+
+            if ack.protocol != PROTOCOL:
+                logger.warning('Invalid protocol [{}] for [{}]', ack.protocol, host)
+                return
+
+            logger.info('Connected to server [{}]', url)
+
+            async for raw in ws:
+                try:
+                    event = ClipboardEvent.model_validate_json(raw)
+
+                    content = ClipboardContent(
+                        mime=event.mime,
+                        data=event.data,
+                    )
+
+                    logger.debug('Seting clipboard from server [{}], mime [{}]', url, mime)
+                    if await is_duplicate_clipboard(content):
+                        logger.debug('Clipboard from server [{}] is duplicate, mime [{}]', url, mime)
+                        continue
+
+                    await set_clipboard(content)
+                    logger.debug('Set clipboard from server [{}], mime [{}]', url, mime)
+                except Exception as e:
+                    logger.error('Error from server [{}]: [{}]', url, e)
+    except Exception as e:
+        logger.warning('Failed to conntect [{}]. Error: [{}]', url, e)

clipik-0.1.0/src/clipik/zeroconf.py

@@ -0,0 +1,120 @@
+import os
+import socket
+import asyncio
+from collections.abc import AsyncGenerator
+from clipik.model import LoseServiceEvent, NewServiceEvent
+from zeroconf import ServiceInfo, Zeroconf, ServiceListener
+from clipik.variables import VERSION, PEER_PORT
+from clipik.logger import logger
+
+
+def _get_local_ip():
+    s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+    s.connect(('8.8.8.8', 80))
+    ip = s.getsockname()[0]
+    s.close()
+    return ip
+
+
+
+SERVICE_NAME = f"clipik-{socket.gethostname()}"
+SERVICE_TYPE = '_clipik._tcp.local.'
+LOCAL_IP = _get_local_ip()
+ZEROCONF = Zeroconf(interfaces=[LOCAL_IP])
+
+
+INFO = ServiceInfo(
+    SERVICE_TYPE,
+    f"{SERVICE_NAME}.{SERVICE_TYPE}",
+    addresses=[socket.inet_aton(LOCAL_IP)],
+    port=PEER_PORT,
+    properties={'version': VERSION},
+)
+
+
+
+class _ServiceListener(ServiceListener):
+    def __init__(self, queue: asyncio.Queue, loop: asyncio.AbstractEventLoop):
+        self.queue = queue
+        self.loop = loop
+
+    def start(self):
+        ZEROCONF.add_service_listener(SERVICE_TYPE, self)
+
+    def stop(self):
+        ZEROCONF.remove_service_listener(self)
+        ZEROCONF.close()
+
+    def add_service(self, zc, type_, name):
+        info = zc.get_service_info(type_, name)
+
+        if info and info.addresses:
+            ip = socket.inet_ntoa(info.addresses[0])
+
+            if ip.startswith('127.'):
+                return
+
+            if ip == LOCAL_IP:
+                logger.debug('Local service registered: [{}] at [{}:{}]', name, ip, info.port)
+                return
+
+            asyncio.run_coroutine_threadsafe(
+                self.queue.put(NewServiceEvent(
+                    name=name,
+                    ip=ip,
+                    host=ip,
+                    port=info.port,
+                )),
+                self.loop,
+            )
+
+            logger.debug('New service [{}] at [{}:{}]', name, ip, info.port)
+
+    def remove_service(self, zc, type_, name):
+        info = zc.get_service_info(type_, name)
+
+        if info and info.addresses:
+            ip = socket.inet_ntoa(info.addresses[0])
+
+            if ip.startswith('127.'):
+                return
+
+            asyncio.create_task(
+                self.queue.put(LoseServiceEvent(
+                    name=name,
+                    ip=ip,
+                    host=ip,
+                    port=info.port,
+                )),
+                self.loop
+            )
+
+            logger.debug('Lose service [{}]', name)
+
+    def update_service(self, zc, type_, name):
+        pass
+
+
+def register_service():
+    ZEROCONF.register_service(INFO)
+    logger.info('Registered service: [{}] at [{}:{}]', SERVICE_NAME, LOCAL_IP, PEER_PORT)
+
+
+def unregister_service():
+    ZEROCONF.unregister_all_services()
+    ZEROCONF.close()
+    logger.info('Unregistered service')
+
+
+async def discover_services() -> AsyncGenerator[NewServiceEvent | LoseServiceEvent, None]:
+    loop = asyncio.get_running_loop()
+    queue = asyncio.Queue()
+    listener = _ServiceListener(queue, loop)
+    listener.start()
+
+    try:
+        while True:
+            event = await queue.get()
+            yield event
+    finally:
+        listener.stop()