pbsync 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: baac0be30f2e90c3fea252ccc0cf94d71f9e75b30574ebb41736d45d5c8f210d
+  data.tar.gz: 9e3cb20d0f47f90e15cebdead17a63b610ea9c83ec69f22314f827084b9371dd
+SHA512:
+  metadata.gz: 86d81c8534135c40f8231f2237057f35e952be688789ad45b59b6243a6ac7fbaf18173d01af2bae5949bad012425bc5c1a73e8dfded6e20e83f9258883cb62dd
+  data.tar.gz: '048c8c96c13c03ba4c81c1298579c82c18d4a0ff1f950b023d2af284a4eb8f9014506a2303fb7e109ffbb01b5b13cfbd9a91b6d674b983a52a101e8ed2d36e05'

data/CLAUDE.md

@@ -0,0 +1,174 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Overview
+
+pbsync is a clipboard synchronization utility implemented as a Ruby gem. It allows bidirectional clipboard syncing between two machines over SSH using Unix domain sockets.
+
+## Architecture
+
+The application operates in two modes:
+- **Server mode** (`pbsync serve`): Listens on a Unix socket at `/tmp/pbsync.sock` and accepts one client connection
+- **Client mode** (`pbsync connect <hostname>`): Establishes SSH tunnel to remote host and connects to the server's socket
+
+Key components:
+- `PBSync::ClipboardSync`: Core synchronization logic that monitors clipboard changes and handles network communication
+- `PBSync::Server`: Server implementation
+- `PBSync::Client`: Client implementation with SSH tunneling
+- `PBSync::CLI`: Command-line interface using Clamp gem for argument parsing
+- Uses clipboard gem for cross-platform clipboard access
+- Binary protocol with 4-byte length prefix (network byte order) followed by UTF-8 message data
+- Maximum clipboard size: 1MB
+- Polling interval: 0.5 seconds
+
+## Ruby Gem Structure
+
+```
+pbsync/
+├── bin/
+│   └── pbsync          # Executable script
+├── lib/
+│   ├── pbsync.rb       # Main module
+│   └── pbsync/
+│       ├── version.rb
+│       ├── cli.rb
+│       ├── clipboard_sync.rb
+│       ├── server.rb
+│       └── client.rb
+├── pbsync.gemspec      # Gem specification
+├── Gemfile
+└── LICENSE
+```
+
+## Installation & Build Commands
+
+```bash
+# Install dependencies
+bundle install
+
+# Build the gem
+gem build pbsync.gemspec
+
+# Install the gem locally
+gem install ./pbsync-0.1.0.gem
+
+# Or install directly from source
+bundle exec rake install
+```
+
+## Usage
+
+```bash
+# Run as server (on remote machine)
+pbsync serve
+pbsync serve --verbose
+
+# Connect as client (on local machine)  
+pbsync connect <hostname>
+pbsync connect <hostname> --verbose
+
+# Show help
+pbsync --help
+pbsync serve --help
+pbsync connect --help
+```
+
+## Testing
+
+The gem includes comprehensive unit and integration tests using RSpec.
+
+```bash
+# Run all tests
+bundle exec rake spec
+
+# Run unit tests only
+bundle exec rake unit
+
+# Run integration tests only
+bundle exec rake integration
+
+# Run tests with coverage report
+bundle exec rake coverage
+
+# Run tests in verbose mode
+bundle exec rake verbose
+```
+
+## Code Quality
+
+The project uses RuboCop for Ruby code linting and style enforcement.
+
+```bash
+# Run RuboCop linter
+bundle exec rake lint
+
+# Run RuboCop with auto-correct
+bundle exec rake lint_fix
+
+# Run RuboCop directly with specific options
+bundle exec rubocop
+bundle exec rubocop --autocorrect-all
+```
+
+### RuboCop Configuration
+
+- Target Ruby version: 2.7+
+- Style guide: Standard Ruby with some customizations
+- Enforced string literals: single quotes
+- Max method length: 20 lines
+- Max class length: 150 lines
+- Line length: 120 characters (except in specs)
+
+### Test Architecture
+
+- **Unit Tests** (`spec/pbsync/`): Test individual classes with mocked dependencies
+  - `clipboard_sync_spec.rb`: Protocol handling, deduplication, thread safety
+  - `server_spec.rb`: Server socket creation and client handling
+  - `client_spec.rb`: SSH tunnel creation and connection management
+
+- **Integration Tests** (`spec/integration/`): Test end-to-end socket communication
+  - Real Unix sockets in temp directories
+  - Bidirectional sync without SSH
+  - Protocol edge cases and error recovery
+
+- **Test Helpers** (`spec/support/`):
+  - `MockClipboard`: Thread-safe clipboard mock for testing
+  - `MockSocket`: Simulated socket for unit testing
+  - `MockSocketPair`: Bidirectional socket pair for integration tests
+
+## Logging
+
+The gem uses Ruby's built-in Logger for output with sensible defaults:
+
+- **Default log level**: INFO (shows important operational messages)
+- **Verbose mode**: DEBUG (shows detailed operational information)
+- **Output**: STDOUT with clean formatting (no timestamps for CLI usage)
+- **Log levels**:
+  - INFO: Normal operational messages (no prefix)
+  - DEBUG: Detailed debugging info ([DEBUG] prefix)
+  - WARN: Warning messages ([WARN] prefix)
+  - ERROR: Error messages ([ERROR] prefix)
+
+### Controlling Log Level
+
+```bash
+# Normal mode (INFO level)
+pbsync connect hostname
+
+# Verbose mode (DEBUG level)
+pbsync connect hostname --verbose
+pbsync serve -v
+
+# In tests (suppressed by default)
+DEBUG_TESTS=1 bundle exec rake spec  # Show debug logs in tests
+```
+
+## Development Notes
+
+- The client assumes `pbsync` is available in the remote machine's $PATH
+- Socket path is hardcoded as `/tmp/pbsync.sock`
+- Dependencies: clipboard gem for clipboard access, clamp gem for CLI parsing
+- Works on macOS, Linux, and Windows (clipboard gem provides cross-platform support)
+- Tests use dependency injection to mock clipboard and socket operations
+- Logger outputs to STDOUT with clean formatting optimized for CLI usage

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Remo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,229 @@
+# PBSync
+
+A Ruby gem for bidirectional clipboard synchronization between machines over SSH using Unix domain sockets.
+
+## Features
+
+- **Bidirectional sync**: Changes on either machine are automatically synchronized
+- **SSH tunneling**: Secure connection between machines
+- **Cross-platform**: Works on macOS, Linux, and Windows (via clipboard gem)
+- **Simple setup**: No configuration files needed
+- **Automatic deduplication**: Prevents sync loops and duplicate transfers
+- **UTF-8 support**: Handles international text and emoji correctly
+- **Size limits**: Protects against oversized clipboard content (1MB max)
+
+## Installation
+
+### From RubyGems (when published)
+
+```bash
+gem install pbsync
+```
+
+### From Source
+
+```bash
+git clone https://github.com/yourusername/pbsync.git
+cd pbsync
+bundle install
+gem build pbsync.gemspec
+gem install ./pbsync-0.1.0.gem
+```
+
+## Usage
+
+### Basic Usage
+
+Simply connect to a remote machine:
+```bash
+pbsync connect hostname
+```
+
+That's it! Your clipboards are now synchronized. Copy text on either machine and it will appear on the other.
+
+The `connect` command automatically:
+1. Establishes an SSH connection to the remote host
+2. Starts the pbsync server on the remote machine
+3. Creates a secure tunnel for clipboard synchronization
+4. Begins monitoring both clipboards for changes
+
+### Verbose Mode
+
+For debugging or to see detailed operation logs:
+```bash
+pbsync connect hostname --verbose
+# or
+pbsync connect hostname -v
+```
+
+### Command Reference
+
+```bash
+# Show help
+pbsync --help
+
+# Connect to remote server (most common usage)
+pbsync connect <hostname> [--verbose]
+
+# Manually start server mode (rarely needed)
+pbsync serve [--verbose]
+
+# Show subcommand help
+pbsync connect --help
+pbsync serve --help
+```
+
+### Manual Server Mode
+
+The `serve` command is available if you need to manually start a server, but this is rarely necessary since `connect` handles it automatically. You might use it for:
+- Testing the server locally
+- Running pbsync in a non-SSH environment
+- Custom networking setups
+
+## How It Works
+
+1. **Server Mode**: Creates a Unix domain socket at `/tmp/pbsync.sock` and waits for connections
+2. **Client Mode**: Establishes an SSH tunnel to the remote host, forwarding the Unix socket
+3. **Monitoring**: Both sides poll their clipboard every 0.5 seconds for changes
+4. **Synchronization**: When a change is detected, it's sent to the other side via the socket
+5. **Deduplication**: Tracks sent and received content to prevent echo loops
+
+### Protocol
+
+PBSync uses a simple binary protocol:
+- 4-byte length prefix (network byte order)
+- UTF-8 encoded clipboard content
+- Maximum message size: 1MB
+
+## Requirements
+
+- Ruby 2.7 or higher
+- SSH access to the remote machine
+- `pbsync` installed on both machines
+- The remote machine must have `pbsync` in its `$PATH`
+
+## Development
+
+### Setup
+
+```bash
+# Clone the repository
+git clone https://github.com/yourusername/pbsync.git
+cd pbsync
+
+# Install dependencies
+bundle install
+```
+
+### Testing
+
+```bash
+# Run all tests
+bundle exec rake spec
+
+# Run with coverage report
+bundle exec rake coverage
+
+# Run specific test suites
+bundle exec rake unit        # Unit tests only
+bundle exec rake integration # Integration tests only
+```
+
+### Code Quality
+
+```bash
+# Run RuboCop linter
+bundle exec rake lint
+
+# Auto-fix linting issues
+bundle exec rake lint_fix
+```
+
+### Building
+
+```bash
+# Build the gem
+gem build pbsync.gemspec
+
+# Install locally for testing
+gem install ./pbsync-0.1.0.gem
+```
+
+## Architecture
+
+```
+┌─────────────┐                    ┌─────────────┐
+│  Local      │                    │  Remote     │
+│  Machine    │                    │  Machine    │
+├─────────────┤                    ├─────────────┤
+│  Clipboard  │◄──┐            ┌──►│  Clipboard  │
+└─────────────┘   │            │   └─────────────┘
+       ▲          │            │          ▲
+       │          │            │          │
+       ▼          │            │          ▼
+┌─────────────┐   │            │   ┌─────────────┐
+│  PBSync     │   │            │   │  PBSync     │
+│  Client     │   │            │   │  Server     │
+├─────────────┤   │            │   ├─────────────┤
+│ Monitor &   │   │            │   │ Monitor &   │
+│ Send/Recv   │   │            │   │ Send/Recv   │
+└─────────────┘   │            │   └─────────────┘
+       ▲          │            │          ▲
+       │          ▼            ▼          │
+       └──────────────────────────────────┘
+              SSH Tunnel + Unix Socket
+
+```
+
+## Troubleshooting
+
+### Connection Issues
+
+If you can't connect:
+1. Ensure `pbsync` is installed on both machines
+2. Verify SSH access: `ssh hostname`
+3. Check that `pbsync` is in the remote machine's `$PATH`
+4. Use verbose mode (`-v`) to see detailed logs
+
+### Clipboard Not Syncing
+
+1. Check that the clipboard contains text (not images or files)
+2. Verify the content is under 1MB
+3. Try verbose mode to see what's being sent/received
+4. Ensure no other clipboard managers are interfering
+
+### Performance
+
+- The default polling interval is 0.5 seconds
+- Large clipboard content (near 1MB) may take longer to sync
+- Network latency affects synchronization speed
+
+## Contributing
+
+1. Fork the repository
+2. Create your feature branch (`git checkout -b feature/amazing-feature`)
+3. Write tests for your changes
+4. Ensure all tests pass (`bundle exec rake spec`)
+5. Check code quality (`bundle exec rake lint`)
+6. Commit your changes
+7. Push to the branch (`git push origin feature/amazing-feature`)
+8. Open a Pull Request
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+## Acknowledgments
+
+- Built with the [clipboard](https://github.com/janlelis/clipboard) gem for cross-platform clipboard access
+- Uses [Clamp](https://github.com/mdub/clamp) for command-line argument parsing
+- Inspired by the need for seamless clipboard sharing in remote development
+
+## Changelog
+
+### 0.1.0 (Initial Release)
+
+- Basic bidirectional clipboard synchronization
+- SSH tunneling support
+- UTF-8 and size limit handling
+- Logging system with verbose mode

data/bin/pbsync

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative '../lib/pbsync'
+
+PBSync::CLI.run

data/lib/pbsync/cli.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'clamp'
+
+module PBSync
+  class CLI < Clamp::Command
+    option ['-v', '--verbose'], :flag, 'Enable verbose logging'
+
+    subcommand 'serve', 'Run in server mode' do
+      def execute
+        PBSync.verbose = verbose?
+        Server.new.run
+      end
+    end
+
+    subcommand 'connect', 'Connect and sync clipboard with host' do
+      parameter 'HOST', 'Hostname to connect to'
+
+      def execute
+        PBSync.verbose = verbose?
+        Client.new(host).run
+      end
+    end
+  end
+end

data/lib/pbsync/client.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require 'socket'
+require 'open3'
+require 'fileutils'
+
+module PBSync
+  class Client
+    def initialize(host)
+      @host = host
+    end
+
+    def run
+      PBSync.logger.info("Entered client mode - host: #{@host}")
+
+      start_ssh_tunnel
+      wait_for_socket
+      connect_to_server
+    rescue Interrupt
+      PBSync.logger.info('Client interrupted')
+    rescue StandardError => e
+      PBSync.logger.error("Client error: #{e.message}")
+      PBSync.logger.debug(e.backtrace.join("\n")) if PBSync.verbose
+    ensure
+      cleanup
+    end
+
+    private
+
+    def start_ssh_tunnel
+      remote_command = 'pbsync serve'
+
+      ssh_args = [
+        'ssh',
+        @host,
+        '-L', "#{SOCKET_PATH}:#{SOCKET_PATH}",
+        'sh', '-c', "'#{remote_command}'",
+      ]
+
+      PBSync.log("Starting SSH tunnel with: #{ssh_args.join(" ")}")
+
+      @stdin, @stdout, @stderr, @ssh_thread = Open3.popen3(*ssh_args)
+
+      Thread.new do
+        while (line = @stderr.gets)
+          PBSync.log("SSH stderr: #{line.strip}")
+        end
+      end
+
+      PBSync.logger.info('SSH tunnel launched')
+    end
+
+    def wait_for_socket
+      PBSync.logger.info('Waiting for socket to become available...')
+
+      30.times do
+        if File.exist?(SOCKET_PATH)
+          sleep 1
+          return
+        end
+        sleep 0.2
+      end
+
+      raise 'Failed to establish SSH tunnel - socket not created'
+    end
+
+    def connect_to_server
+      raise "Socket not found at #{SOCKET_PATH}" unless File.exist?(SOCKET_PATH)
+
+      PBSync.logger.info('Socket available, connecting...')
+
+      socket = UNIXSocket.new(SOCKET_PATH)
+      PBSync.logger.info("Connected to remote server via #{@host}")
+
+      sync = ClipboardSync.new(socket)
+      sync.start
+
+      PBSync.logger.info('Entering client loop')
+
+      Signal.trap('INT') do
+        PBSync.logger.info('Shutting down client...')
+        sync.stop
+        cleanup
+        exit(0)
+      end
+
+      sleep
+    end
+
+    def cleanup
+      @ssh_thread&.kill
+      [@stdin, @stdout, @stderr].each { |io| io&.close }
+      FileUtils.rm_f(SOCKET_PATH)
+    end
+  end
+end

data/lib/pbsync/clipboard_sync.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+module PBSync
+  class ClipboardSync
+    attr_reader :running
+
+    def initialize(socket, clipboard_adapter: Clipboard)
+      @socket = socket
+      @clipboard = clipboard_adapter
+      @last_clipboard_sent = nil
+      @last_clipboard_received = nil
+      @running = true
+    end
+
+    def start
+      start_clipboard_monitor
+      start_receive_loop
+    end
+
+    def stop
+      @running = false
+      begin
+        @socket.close
+      rescue StandardError
+        nil
+      end
+    end
+
+    private
+
+    def get_clipboard_text
+      text = @clipboard.paste
+      return nil if text.nil? || text.empty?
+      return nil if text.bytesize > MAX_SIZE
+
+      text
+    rescue StandardError => e
+      PBSync.log("Error reading clipboard: #{e.message}")
+      nil
+    end
+
+    def set_clipboard_text(text)
+      PBSync.log("Setting clipboard: #{text[0..99]}...")
+      @clipboard.copy(text)
+    rescue StandardError => e
+      PBSync.log("Error setting clipboard: #{e.message}")
+    end
+
+    def send_clipboard(text)
+      return unless text
+
+      data = text.encode('UTF-8')
+      length = [data.bytesize].pack('N')
+      packet = length + data
+
+      @socket.write(packet)
+      @socket.flush
+      PBSync.logger.info("📤 Sent clipboard (#{data.bytesize} bytes): \"#{text[0..99]}\"")
+    rescue StandardError => e
+      PBSync.log("Error sending clipboard: #{e.message}")
+    end
+
+    def read_exact(size)
+      data = ''
+      while data.bytesize < size
+        chunk = @socket.read(size - data.bytesize)
+        return nil if chunk.nil? || chunk.empty?
+
+        data += chunk
+      end
+      data
+    rescue StandardError => e
+      PBSync.log("Error reading from socket: #{e.message}")
+      nil
+    end
+
+    def start_clipboard_monitor
+      PBSync.logger.info('📋 Starting clipboard monitor')
+      Thread.new do
+        while @running
+          begin
+            PBSync.log('⏱️ Clipboard poll fired')
+            text = get_clipboard_text
+
+            if text.nil?
+              PBSync.log('📋 Clipboard is empty or invalid')
+            elsif text == @last_clipboard_sent
+              PBSync.log('📋 Clipboard unchanged (already sent)')
+            elsif text == @last_clipboard_received
+              PBSync.log('📋 Clipboard came from remote (already received)')
+            else
+              PBSync.log('📋 Clipboard changed → sending')
+              @last_clipboard_sent = text
+              send_clipboard(text)
+            end
+
+            sleep POLL_INTERVAL
+          rescue StandardError => e
+            PBSync.log("Error in clipboard monitor: #{e.message}")
+            sleep POLL_INTERVAL
+          end
+        end
+      end
+    end
+
+    def start_receive_loop
+      PBSync.logger.info('📥 Starting receive loop')
+      Thread.new do
+        while @running
+          begin
+            length_data = read_exact(4)
+            unless length_data && length_data.bytesize == 4
+              PBSync.logger.info('🔌 Disconnected (no length)')
+              break
+            end
+
+            length = length_data.unpack1('N')
+            message_data = read_exact(length)
+            unless message_data
+              PBSync.logger.info('Disconnected or bad message')
+              break
+            end
+
+            received = message_data.force_encoding('UTF-8')
+
+            if received != @last_clipboard_sent && received != @last_clipboard_received
+              @last_clipboard_received = received
+              set_clipboard_text(received)
+              PBSync.logger.info("📥 Received clipboard (#{message_data.bytesize} bytes): \"#{received[0..99]}\"")
+            else
+              PBSync.log('📥 Ignored duplicate clipboard content')
+            end
+          rescue StandardError => e
+            PBSync.log("Error in receive loop: #{e.message}")
+            break
+          end
+        end
+
+        stop
+        exit(0)
+      end
+    end
+  end
+end

data/lib/pbsync/server.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'socket'
+require 'fileutils'
+
+module PBSync
+  class Server
+    def run
+      PBSync.logger.info('Entered server mode')
+
+      FileUtils.rm_f(SOCKET_PATH)
+
+      server = UNIXServer.new(SOCKET_PATH)
+      PBSync.logger.info("Server listening on #{SOCKET_PATH}")
+
+      client_socket = server.accept
+      PBSync.logger.info('Client connected')
+
+      sync = ClipboardSync.new(client_socket)
+      sync.start
+
+      PBSync.logger.info('Entering server loop')
+
+      Signal.trap('INT') do
+        PBSync.logger.info('Shutting down server...')
+        sync.stop
+        server.close
+        FileUtils.rm_f(SOCKET_PATH)
+        exit(0)
+      end
+
+      sleep
+    rescue Interrupt
+      PBSync.logger.info('Server interrupted')
+    rescue StandardError => e
+      PBSync.logger.error("Server error: #{e.message}")
+      PBSync.logger.debug(e.backtrace.join("\n")) if PBSync.verbose
+    ensure
+      FileUtils.rm_f(SOCKET_PATH)
+    end
+  end
+end

data/lib/pbsync/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module PBSync
+  VERSION = '0.1.0'
+end

data/lib/pbsync.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require 'socket'
+require 'clipboard'
+require 'timeout'
+require 'logger'
+require_relative 'pbsync/version'
+require_relative 'pbsync/clipboard_sync'
+require_relative 'pbsync/server'
+require_relative 'pbsync/client'
+require_relative 'pbsync/cli'
+
+module PBSync
+  SOCKET_PATH = '/tmp/pbsync.sock'
+  MAX_SIZE = 1_000_000
+  POLL_INTERVAL = 0.5
+
+  class << self
+    def logger
+      @logger ||= create_logger
+    end
+
+    attr_writer :logger
+
+    def verbose=(value)
+      logger.level = value ? Logger::DEBUG : Logger::INFO
+    end
+
+    def verbose
+      logger.level == Logger::DEBUG
+    end
+
+    # Compatibility method for existing code
+    def log(message)
+      logger.debug(message)
+    end
+
+    private
+
+    def create_logger
+      log = Logger.new($stdout)
+      log.level = Logger::INFO
+      log.formatter = proc do |severity, _datetime, _progname, msg|
+        # Simple format without timestamp for cleaner CLI output
+        case severity
+        when 'DEBUG'
+          "[DEBUG] #{msg}\n"
+        when 'WARN'
+          "[WARN] #{msg}\n"
+        when 'ERROR'
+          "[ERROR] #{msg}\n"
+        else
+          "#{msg}\n"
+        end
+      end
+      log
+    end
+  end
+end

metadata

@@ -0,0 +1,122 @@
+--- !ruby/object:Gem::Specification
+name: pbsync
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Remo
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: clipboard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: clamp
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: logger
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: Bidirectional clipboard syncing between machines over SSH using Unix
+  sockets
+executables:
+- pbsync
+extensions: []
+extra_rdoc_files: []
+files:
+- CLAUDE.md
+- LICENSE
+- README.md
+- bin/pbsync
+- lib/pbsync.rb
+- lib/pbsync/cli.rb
+- lib/pbsync/client.rb
+- lib/pbsync/clipboard_sync.rb
+- lib/pbsync/server.rb
+- lib/pbsync/version.rb
+homepage: https://github.com/sudoremo/pbsync
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/sudoremo/pbsync
+  source_code_uri: https://github.com/sudoremo/pbsync
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.8
+specification_version: 4
+summary: Clipboard synchronization utility for macOS
+test_files: []