The Problem

In Leopard, both pbcopy and pbpaste appear to crash when run from GNU screen. I did some basic investigation and found that pbcopy and pbpaste work by talking to a daemon called pboard, which is managed by launchd in Leopard. Any subprocess launched by GNU screen seems to be unable to talk to pboard, though pbcopy does work with a pboard instance launched from within screen. Unfortunately this defeats the purpose because the pboard instance launched in screen does not work with the OS.

I was not successful in uncovering the reason that pbcopy in screen can’t talk to the pboard process started by launchd. If anyone knows why this is the case I would be very, very happy to hear about it.

My Solution

I realized that if I could somehow get pbcopy running in screen to talk to the pboard running outside of screen then I could write to the Leopard clipboard from screen. The solution I came up with is to start a process outside of screen that listens on a UNIX domain socket. When it receives a message it copies it to the Leopard clipboard using pbcopy. Within screen I use a client that pushes screen’s /tmp/screen-exchange file over the UNIX domain socket.

Here are the scripts:

• pboard_server
• pboard_client

You will need to chmod 755 pboard_server pboard_client after downloading them. To use the new pboard client, add the following to your .screenrc:

bind b eval "writebuf" "exec ruby pboard_client"

If you used my previous tutorial, the line above should replace the old bind b ... line.

Now when you open a terminal (outside of screen), run pboard_server &. This will start the process that listens for requests over the socket. You only need to do this once when you login, and you could automate this using launchd or some shell scripting from your .bashrc.

You should now be able to start screen and copy to the clipboard!

If you’ve never used Screen, but frequently use console applications, it is definitely a tool worth exploring. An introduction to Screen can be found on the Kuro5hin website.

In this article I share my experience with one of my favorite screen features: its scrollback buffer. As you interact with a Screen window, Screen stores a configurable number of lines of history in its scrollback buffer. The scrollback buffer makes it easy to browse or even search through the history of your windows. In addition, it makes it easy to copy and paste any section of text from the history.

Configuring the Scrollback Buffer

By default, the scrollback buffer only keeps the last 100 lines of text, which is not enough for my typical interaction with Screen. I’ve found a setting of 5000 lines to be more than adequate for my usage. The number of scrollback lines can be configured in your $HOME/.screenrc file, by adding the following line:

defscrollback 5000

This sets the scrollback to 5000 lines.

You can also override this default value when starting screen using the -h [num] option, where num is the number of scrollback lines.

Finally, if you want to change the number of lines of scrollback for a single window, using the “scrollback” command. Hit C-a (Ctrl-A) : to go to the Screen command line and type scrollback num, where num is the number of scrollback lines.

You can check the number of scrollback lines in your window. Hit C-a i to display window information. You will see a status line with information similar to the following:

(27,42)/(186,42)+20 +flow UTF-8 3(bash)

In this case, my scrollback is 20 lines (it is displayed as +20 in the output above).

Entering Scrollback Mode and Navigating

To enter scrollback hit C-a [. A status line will indicate that you've entered copy mode. To exit scrollback mode, hit the escape button.

Navigating in scrollback mode will be pretty familiar to VI users. Here are some of the most common navigation keys (taken from the screen manpage):

h -    Move the cursor left by one character
j -    Move the cursor down by one line
k -    Move the cursor up by one line
l -    Move the cursor right by one character
0 -    Move to the beginning of the current line
$ -    Move to the end of the current line.
G -    Moves to the specified line
       (defaults to the end of the buffer).
C-u -  Scrolls a half page up.
C-b -  Scrolls a full page up.
C-d -  Scrolls a half page down.
C-f -  Scrolls the full page down.

I often use the page up and page down commands to quickly scroll back through the window's history.

In addition to traditional navigation, Screen allows you to search the scrollback buffer using the following commands:

/ -    Search forward
? -    Search backward

Search is a very useful feature. For example, you could run a script and search for keywords in the output (such as Error), without having to redirect the output.

Copy and Paste

Scrollback mode is also know as copy mode and it allows you to copy any section of text into a copy buffer. To copy text, move the cursor to the start of the text you want to copy, hit spacebar, move the cursor to the end of the text you want to copy (Screen will highlight the text to be copied as you move), and again hit spacebar. Screen will indicate the number of characters copied into the copy buffer.

To paste text, simply hit C-a ].

Copying to the Mac Clipboard

While copying and pasting in a terminal is very useful, I also find that I often want to copy some text from a terminal into my clipboard. This next tip will show you how to do this for Mac OSX, but I’m sure it can be easily modified to work with other operating systems.

Open $HOME/.screenrc and add the following line:

bind b eval "writebuf" "exec sh -c 'pbcopy < /tmp/screen-exchange'"

This line tells Screen to write its copy buffer to a temporary file (defaults to /tmp/screen-exchange), and then sends that file to pbcopy, a Mac OSX utility that copies text into the Mac clipboard. In this case, I’ve bound the command to C-a b, but you can change to best suit your own environment.

Conclusion

This wraps up my review of Screen’s scrollback buffer. I hope this tutorial is useful, especially to those that frequently work in terminal windows.

Do you have interesting ways of using Screen’s scrollback buffer, or Screen in general?