gem-hunter

The Clipboard Project cannot continue development unless I receive help from someone who knows C++.

If you are this person, please email me at engineer@ucf.edu

Available for MacOS, Linux, & Windows

curl -sSL https://github.com/Slackadays/Clipboard/raw/main/install.sh | sh

(Invoke-WebRequest -UseBasicParsing https://github.com/Slackadays/Clipboard/raw/main/install.ps1).Content | powershell

apk add clipboard

yay -S clipboard

yay -S clipboard-bin

yay -S clipboard-git

conda install -c conda-forge cb-clipboard

mamba install -c conda-forge cb-clipboard

micromamba install -c conda-forge cb-clipboard

pixi global install cb-clipboard

flatpak install app.getclipboard.Clipboard
# After installing, do "alias cb='flatpak run app.getclipboard.Clipboard'" to use CB easily.
# Then, add that command to your terminal profile (like .bashrc) to make it work every time.

emerge -av app-misc/clipboard

brew install clipboard

nix-env -iA nixpkgs.clipboard-jh

pacstall -I clipboard-bin

scoop install clipboard

sudo snap install clipboard
# After installing, do "alias cb='snap run clipboard'" to use CB easily.
# Then, add that command to your terminal profile (like .bashrc) to make it work every time.

sudo xbps-install -S Clipboard

winget install -e --id Slackadays.Clipboard

# For all platforms except Windows, Flatpak, and Snap
$ export PATH=$PATH:/where/you/unpacked/cb
# Add this to your terminal startup file like .bashrc or the equivalent so that it works every time.
# To get the current path (in case you don't know it), do the "pwd" command.

# For Flatpak
$ alias cb='flatpak run app.getclipboard.Clipboard'
# Add this to your terminal startup file like .bashrc or the equivalent so that it works every time.

# For Snap
$ alias cb='snap run clipboard'
# Add this to your terminal startup file like .bashrc or the equivalent so that it works every time.

# For Windows PowerShell
> $Env:PATH += ";C:\where\you\unpacked\cb"
# Add this to your PowerShell profile (which is located in $profile) so that this works every time.
# To get the current path (in case you don't know it), do the "Get-Location" command.

# First, let's download the code and go a nice place to build everything.
$ git clone https://github.com/Slackadays/Clipboard 
$ cd Clipboard/build

# Now let's set up CMake and build CB.
$ cmake -DCMAKE_BUILD_TYPE=Release ..
$ cmake --build . -j 12

# Finally, let's install it onto our system.
$ cmake --install .

# Let's start by copying a file.
$ cb copy NuclearLaunchCodes.pdf

# Now, let's paste this file.
$ cb paste

# Not bad, right?

# Let's make a note for this clipboard.
$ cb note "Keep this a secret"

# What if you wanted to pipe the note in?
$ echo "Keep this a secret OR ELSE" | cb note

# Now let's cut a directory to a different clipboard.
$ cb cut69 MyDirectory

# We put the 69 right after "cut" to tell CB to put MyDirectory in clipboard 69.

# Let's add a file to this same clipboard.
$ cb add69 SomeFile

# To remove a file, enter its name to remove just that file.
$ cb remove69 SomeFile

# Alternatively, you can put in a regex pattern instead to generalize the removal.
$ cb remove69 "So.*le"

# Finally, let's paste what we have in clipboard 69.
$ cb paste69

# You can copy multiple files at the same time. 
# Let's try the "_420" persistent clipboard for this one.
$ cb copy_420 foo.bar NotAVirus.bar.mp3.exe

# Like before, we can remove anything with a regex patttern.
$ cb remove_420 "*.mp3\.exe"

# Notes work exactly the same way for every clipboard.
$ cb note_420 "Some kosher content here"

# Let's look at everything we've stored in clipboard _420.
$ cb show_420

# Now let's see our original note and then clear that clipboard. 
$ cb note
$ cb clear

# This is the same as "cb note" but for clipboard "_420" again.
$ cb note_420

# Let's shake things up. Say you have some kind of content you want to ignore.
# This content could be anything from a password to raw binary data.
# To ignore certain kinds of content, use a regex pattern of your choice.

# Let's try this with a classic example.
$ cb ignore "H.*2"

# This pattern will ignore anything starting with "H" and ending with "2."

# Now, this next command will fail because CB will ignore the content in it through the pattern.
$ cb copy "Hunter2"

# Let's get some more detailed information about our clipboards.
$ cb info
$ cb info69
$ cb info_420

# To wrap things up, let's get a bird's eye view of everything so far.
$ cb
# Doing "cb" is the exact same as "cb status."
$ cb status

# These are just a handful of examples. 
# Check the documentation below for tons more examples of all the commands!

Copy   cb [--](copy|cp)[(num)|_(id)] (file) [files] or (something) | cb [[--](copy|cp)][(num)|_(id)]

$ cb copy FooFile
$ cb --copy FooFile
$ cb cp FooFile 
$ cb --cp FooFile
# These are the same!

$ cb copy FooFile BarDir
# These are also the same!

$ echo "Foobar" | cb
$ echo "Foobar" | cb copy 
# The "copy" action is optional here since the only possible action here in the first place is "copy"

$ cb copy "Aventura was the best bachata band"

$ cb copy4 FooFile

$ echo "Foobar" | cb copy_hello

$ cb --clipboard hey copy "Aventura was the best bachata band"
$ cb -c hey copy "Aventura was the best bachata band" 
# These are the same!

$ cb cp50 "Aventura/God's Project/04 Un Chi Chi.flac" BarDir BazDir

Cut   cb [--](cut|ct)[(num)|_(id)] (file) [files] or (something) | cb [[--](cut|ct)][(num)|_(id)]

$ cb cut FooFile
$ cb --cut FooFile
$ cb ct FooFile 
$ cb --ct FooFile
# These are the same!

$ cb cut FooFile BarDir
# These are also the same!

$ echo "Foobar" | cb cut

$ cb cut "Hunter2"

$ cb cut4 FooFile

$ echo "Foobar" | cb cut_hello

$ cb --clipboard hey cut "Aventura was the best bachata band"
$ cb -c hey cut "Aventura was the best bachata band"
# These are the same!

$ cb ct50 "Aventura/God's Project/04 Un Chi Chi.flac" BarDir BazDir

Paste   cb [--](paste|p)[(num)|_(id)] [regex] [regexes] or cb [[--](paste|p][(num)|_(id)] | (something) or cb [[--](paste|p)][(num)|_(id)] > (some file)

$ cb copy FooFile WhyAventuraIsTheBest.pdf

$ cb paste
$ cb --paste
$ cb p
$ cb --p
# These are the same!

$ cb p ".*Aventura.*"

$ echo "Bananas!" | cb

$ cb paste
# Also the same

$ cb paste > SomeFile

$ cb paste42 > SomeFile
$ cb p42 > SomeFile
$ cb -c 42 > SomeFile 
# These three versions all work great!

$ cb | cat
# These three versions also all work great.
$ cb | Write-Output 
# The version for PowerShell

$ cb paste_2 | cat
$ cb p_2 | cat
$ cb -c _2 | cat 
# These three versions also all work great.
$ cb -c _2 | Write-Output 
# The version for PowerShell

Add Contents   cb [--](add|ad)[(num)|_(id)] (file|text) [files] or (something) | cb [[--](add|ad)][(num)|_(id)]

$ cb copy FooFile

$ cb add SomeOtherFile
$ cb --add SomeOtherFile
$ cb ad SomeOtherFile 
$ cb --ad SomeOtherFile
# CB now holds FooFile and SomeOtherFile

$ cb add "We Broke The Rules"

$ cb copy "'Let me find that'"

$ cb add " is one of Romeo Santos' catchphrases."
# The content is now: 'Let me find that' is one of Romeo Santos' catchphrases.

$ echo " What's yours?" | cb add 
# The content is now: 'Let me find that' is one of Romeo Santos' catchphrases. What's yours?

Remove Contents   cb [--](remove|rm)[(num)|_(id)] (regex) [regexes] or (some regex) | cb [[--](remove|rm)][(num)|_(id)]

$ cb copy FooFile BarDir BazDir

$ cb remove "B.*"
$ cb --remove "B.*"
$ cb rm "B.*"
$ cb --rm "B.*"
# CB will match this against "BarDir" and "BazDir" and remove them

$ cb remove "BarDir"
# CB will match this against "BarDir" only and remove it

$ cb copy "A bachatero is someone who makes bachata music."

$ cb remove "(?<= ).*ero"
# The content is now: A  is someone who makes bachata music.

$ echo "music" | cb remove
# The content is now: A  is someone who makes bachata .

Show Contents   cb [--](show|sh)[(num)|_(id)] [regex] [regexes] or cb [--](show|sh)[(num)|_(id)] [regex] [regexes] | (something)

$ cb copy FooFile BarDir BazDir

$ cb show
$ cb --show
$ cb sh 
$ cb --sh
# These all work great!

$ cb copy "Those who are tired of bachata are tired of life"

$ cb show

$ cb sh | cat

$ cb copy "02 I Believe.flac"
$ eval vlc $(cb sh)
# Use the eval command here to process the raw filepath (which in this case looks like "/tmp/Clipboard/0/02 I Believe.flac") as if it were entered in a shell
# Otherwise, you'll likely get errors complaining about being unable to process quote characters.

Clear Clipboard   cb [--](clear|clr)[(num)|_(id)]

$ cb copy FooFile BarDir BazDir

$ cb clear
$ cb --clear
$ cb clr 
$ cb --clr
# These all work great!

$ cb clear 69-420
# Clears entries 69 through 420 inclusive
$ cb clr 0-100
# Clears entries 0 through 100 inclusive
# Note: Entry 0 is always the most recent one

$ cb clear -a
# Note: This will really clear everything in all clipboards!

Edit Clipboard Content   cb [--](edit|ed)[(num)|_(id)] [editor]

$ cb copy "Hello Clipboard! This is just some example content."

$ cb edit
$ cb --edit
$ cb ed
$ cb --ed
# These all work great!

cb edit nano
cb ed vim
cb ed code

Add Script to Clipboard   cb [--](script|sc)[(num)|_(id)] [script path|content]

$ cb script pwd # Note: The exact output of "pwd" will vary depending on your system.
$ cb
/run/user/1000/Clipboard/0/data/0
# The output of CB will be here
/run/user/1000/Clipboard/0/data/0

$ cat myscript.sh
echo "Hello Clipboard!"
echo "Here's what's in the directory:"
ls
$ cb script myscript.sh
$ cb
Hello Clipboard!
Here's what's in the directory:
rawdata.clipboard
# The output of CB will be here
Hello Clipboard!
Here's what's in the directory:
rawdata.clipboard

$ cb script ls --actions search,history
$ cb
$ cb history
rawdata.clipboard
# The output of CB will be here
rawdata.clipboard
$ cb search
rawdata.clipboard
# The output of CB will be here
rawdata.clipboard
$ cb copy
$

$ cb script ls --timings before
$ cb
rawdata.clipboard
# The output of CB will be here
$ cb script ls --timings after
$ cb
# The output of CB will be here
rawdata.clipboard
$ cb script ls --timings before,after
rawdata.clipboard
# The output of CB will be here
rawdata.clipboard

$ cb script ls --actions copy --timings before
$ cb
$ cb copy
rawdata.clipboard
# The output of CB will be here

$ cb script
# Script content shows here

Load Contents   cb [--](load|ld)[(num)|_(id)] [clipboard] [clipboards]

$ cb copy "Yo dawg! I heard you liked bachata music."

$ cb load 1 2 3 _foo
$ cb --load 1 2 3 _foo
$ cb ld 1 2 3 _foo
$ cb --ld 1 2 3 _foo
# All work great!

$ cb load_foo

Swap Contents   cb [--](swap|sw)[(num)|_(id)] [clipboard]

$ cb copy "After breaking up from Aventura, Romeo Santos' music just wasn't up to snuff."
$ cb copy2 "I'd just like to interject for a moment. What you're referring to as Linux, is in fact, GNU/Linux, or as I've recently taken to calling it, GNU plus Linux."

$ cb swap 2
$ cb --swap 2
$ cb sw 2
$ cb --sw 2
# All work great!

$ cb swap2
$ cb --swap2
$ cb sw2
$ cb --sw2
# Since swapping is commutative, the target can be freely swapped with the destination.

Import Clipboards   cb [--](import|imp) [source folder]

$ cb copy "The reason Aventura was so popular was because the music was so well-written as well as the luscious guitar chorus effect."
$ cb export

$ cb import
$ cb --import
$ cb imp
$ cb --imp
# These all work great!

$ cb import MySavedClipboards

Export Clipboards   cb [--](export|ex) [clipboard] [clipboards]

$ cb copy "Aventura's music is some of the most erotic you'll find anywhere."

$ cb export
$ cb --export
$ cb ex
$ cb --ex
# These all work great!

$ cb export 1 2 3

Queue Clipboard History   cb [--](history|hs)[(num)|_(id)]

$ cb copy "There are at least two \"Anthony Santos\" who are known for bachata music: the \"regular\" Anthony Santos and Anthony \"Romeo\" Santos."
$ cb copy "blah blah blah"
$ cb copy "Clipboard Project is the best clipboard manager around"

$ cb history
$ cb --history
$ cb hs
$ cb --hs
# These all work great!

Get Older Clipboard Entries   cb [--](history|hs)[(num)|_(id)] (clipboard) [clipboards]

$ cb copy "There are at least two \"Anthony Santos\" who are known for bachata music: the \"regular\" Anthony Santos and Anthony \"Romeo\" Santos."
$ cb copy "blah blah blah"
$ cb copy "Clipboard Project is the best clipboard manager around"

$ cb history 1
$ cb --history 2
$ cb hs 1
$ cb --hs 1 2
# These all work great!

Set Note   cb [--](note|nt)[(num)|_(id)] (text) or (something) | cb [[--](note|nt)][(num)|_(id)]

$ cb note "For my Aventura music collection"
$ cb --note "For my Aventura music collection"
$ cb nt "For my Aventura music collection"
$ cb --nt "For my Aventura music collection"
# All work great!

$ echo "For my Aventura music collection" | cb note

$ cb note ""

Show Note   cb [--](note|nt)[(num)|_(id)]

$ cb note "For my Aventura music collection"

$ cb note
$ cb --note
$ cb nt
$ cb --nt

Set Ignore Rules   cb [--](ignore|ig)[(num)|_(id)] (regex) [regexes] or (regex) | cb [[--](ignore|ig)][(num)|_(id)]

$ cb ignore "(?<![A-Za-z0-9/+=])[A-Za-z0-9/+=]{40}(?![A-Za-z0-9/+=])"
$ cb --ignore "(?<![A-Za-z0-9/+=])[A-Za-z0-9/+=]{40}(?![A-Za-z0-9/+=])"
$ cb ig "(?<![A-Za-z0-9/+=])[A-Za-z0-9/+=]{40}(?![A-Za-z0-9/+=])"
$ cb --ig "(?<![A-Za-z0-9/+=])[A-Za-z0-9/+=]{40}(?![A-Za-z0-9/+=])"
# All work great!
# "(?<![A-Za-z0-9/+=])[A-Za-z0-9/+=]{40}(?![A-Za-z0-9/+=])" is the regex for an AWS SK secret.

$ echo "[abc]{10}" | cb ignore

$ cb ignore ""

Show Ignore Rules   cb [--](ignore|ig)[(num)|_(id)]

$ cb ignore "Foo" "Bar" "Baz"

$ cb ignore
$ cb --ignore
$ cb ig
$ cb --ig

Show Detailed Info   cb [--](info|in)[(num)|_(id)] or cb [--](info|in)[(num)|_(id)] | (something)

$ cb info
$ cb --info
$ cb in
$ cb --in
# All are the same!

$ cb info | cat
$ cb info | jq

Search Clipboard Contents   cb [--](search|sr)[(num)|_(id)] (query) [queries]

$ cb copy Foo Bar Baz
$ cb copy "Some example content"
$ cb copy2 "Blah bleh bluh bloh"

$ cb search Foo
$ cb --search Blah
$ cb sr Bar
$ cb --sr Baz
# All are the same!

Show Help Message   cb (-h|[--]help)

$ cb help
$ cb --help
$ cb -h 
# These three versions all work great!

Check All Clipboards' Status   cb [[--]status|st] or cb [--](status|st) | (something)

$ cb status
$ cb --status
$ cb st
$ cb --st
$ cb 
# These all work great!

$ cb status | cat

Check Your Configuration   cb [[--]config|cfg]

$ cb config
$ cb --config
$ cb cfg
$ cb --cfg
# These all work great!

$ cb cp_theta θ
$ cb -c amog cp ඞ

# Vim
:r !cb
# Nano
[Ctrl-T] cb
# VSCode
cb | code -

$ cb cut "AVeryStrongPassword!"
$ cb | some-program
# Now gone

$ neofetch | cb cp_neo
$ cb | cat

$ env | yank -d = -- cb

$ cb cp "$(cb st | jq -r '.[] | if type=="array" then .[].path else if type=="object" then .path else . end end' | dmenu)"
# For copying the latest entry from any of your clipboards
$ cb cp "$(cb hs | jq -r '.[].content | if type=="array" then .[].path else if type=="object" then .path else . end end' | dmenu)"
# For copying any entry from a specific clipboard

$ journalctl | cb
# For systemd
$ sudo dmesg | cb
# For Linux; note that you're not running "sudo cb" here
$ cb copy logs/latest.log
# For Minecraft servers

# This one looks like The Matrix
$ export CLIPBOARD_THEME=green
$ cb
# This one is for light backgrounds
$ export CLIPBOARD_THEME=light
$ cb
# Check out the other themes too!

#!/bin/sh
# This script does nothing except serve as an example of automating CB.
link="https://SomeWebsiteWithLotsOfContent"
wget link
cb copy *.jpg *.png
cb remove "AZ.*\.png"
cb | tar -cf foobar.tar
cb -c footar < foobar.tar
cb note "Latest files from website ABCXYZ"

--all, -a   Add this when clearing to clear all clipboards at once, or when searching to search all clipboards.

$ cb --all clear

--clipboard (clipboard), -c (clipboard)   Add this to choose which clipboard you want to use.

$ cb -c 5 copy Foobar
$ cb --clipboard 10 copy BarBaz

$ cb -c SomeCB copy "A really really long sentence, and I mean really really super DUPER long!"

$ cb -c _ copy "Generation Next"/*

--entry (entry), -e (entry)   Add this to choose which history entry you want to use.

$ cb -e 5 copy Foobar
$ cb --entry 10 copy BarBaz

--fast-copy, -fc   Add this to use links when copying, cutting, pasting, or loading. If you modify the items that you used with this flag, then the items you paste will have the same changes.

$ cb --fast-copy copy /usr/bin/*

--mime, -m   Add this to request a specific content MIME type from GUI clipboard systems.

$ cb --mime text/html | cb

--no-confirmation, -nc   Add this to disable confirmation messages from CB.

$ cb -nc sh | cat

--no-progress, -np   Add this to disable progress messages from CB.

$ fzf | cb -np

--secret   Add this when ignoring content to ignore a secret (or secrets) instead.

$ cb ignore --secret MyVerySecurePassword
$ cb ignore --secret # This will show the SHA512 hash of MyVerySecurePassword
$ cb ignore --secret MyVerySecurePassword2 "someOTHER secret1 banana"
$ cb ignore --secret # Now it will show the SHA512 hashes of MyVerySecurePassword2 and someOTHER secret1 banana

$ cb ignore --secret ""
# WARNING: Once you clear all secrets, there is no going back.

--bachata   Add this for something special!

$ cb --bachata

CI   Set this to "true" or "1" to make CB overwrite existing items without a user prompt when pasting. This variable is intended for Continuous Integration scripts where a live human is not present to make decisions.

...
cb cp Temp/*
...
cb p
...

CLIPBOARD_ACTION   CB will set this to the current action when running a script.

$ cb script ls
$ cb history
# Now, whatever script CB runs will have access to the CLIPBOARD_ACTION environment variable, here with value "history"

CLIPBOARD_EDITOR   Set this to the editor you want to use for the Edit action.

$ export CLIPBOARD_EDITOR=nano

CLIPBOARD_HISTORY   Set this to the maximum history size you want to keep, like 10000 or 50gb.

$ export CLIPBOARD_HISTORY=1000000000
$ cb copy "Oh yeah!"

$ export CLIPBOARD_HISTORY=100tb
$ cb copy Yo_Mama.tar.gz

$ export CLIPBOARD_HISTORY=52w

CLIPBOARD_LOCALE   Set this to the locale that only CB will use for its commands and output, like en_US.UTF-8 or es_DO.UTF-8.

$ export CLIPBOARD_LOCALE=es_DO.UTF-8
$ cb cp "Amo a Aventura"

> $Env:CLIPBOARD_LOCALE=es_DO.UTF-8
# Powershell version

$ export CLIPBOARD_LOCALE=fr_CA.UTF-8
...
$ CLIPBOARD_LOCALE="" cb cp Foobar

CLIPBOARD_SCRIPT_TIMING   CB will set this to the timing of the script that it runs.

$ cb script ls
$ cb history
# Now, whatever script CB runs will have access to the CLIPBOARD_SCRIPT_TIMING environment variable, here with value "before"
# (output of "cb history")
# Now, CLIPBOARD_SCRIPT_TIMING will have value "after"

CLIPBOARD_TMPDIR   Set this to the directory that only CB will use to hold the items you cut or copy into a temporary directory.

$ CLIPBOARD_TMPDIR=/home/jackson/SomeDirectory cb copy *

$ export CLIPBOARD_TMPDIR=/home/jackson/SomeDirectory
$ cb copy *
> $Env:CLIPBOARD_TMPDIR = /home/jackson/SomeDirectory
# Powershell