@hellix-ai/cubes 0.2.0 → 0.2.1

package/README.md

@@ -35,6 +35,11 @@ Every key goes to the session, exactly as if Claude Code were running locally, e
 | `Ctrl-]` | detach. The session keeps running. |
 | `Ctrl-V` | paste the image on your clipboard: it is uploaded to the session and its path typed in (macOS, and Linux with `wl-paste` or `xclip`). With no image on the clipboard, Ctrl-V goes through unchanged. |
 
+**Copying.** Drag over text in a session and it is copied the moment you let go - the session's tmux
+does the selecting (so there is no selection left for Cmd+C), and the CLI puts the text on your
+clipboard. Claude Code's own copy (the `c` on its login URL) lands there too. On Linux this needs
+`wl-copy`, `xclip` or `xsel`.
+
 **One keyboard per session.** Attaching takes the keyboard from any browser tab open on the same session
 (that tab becomes read-only, with a Take over button) and fits the session to your window. If someone
 takes it back, the terminal says so and goes read-only; detach and attach again to reclaim it.

package/dist/attach.js

@@ -64,7 +64,20 @@ export function attach(deps, session, opts = {}) {
         let pasting = false;
         // Our own sequences (title, bell, notifications) wait here until the session's stream is between
         // escape sequences - see termstatus.ts. A fresh filter per connection: a replay starts clean.
-        let stream = new StreamFilter();
+        // ⚠ ONLY THE KEYBOARD COPIES. The session's output reaches every viewer, so a `c` pressed in a
+        // browser tab on the same session would otherwise overwrite THIS person's clipboard too. The web
+        // terminal draws the same line (Terminal.tsx, its OSC 52 handler).
+        const onClipboard = deps.clipboard ? (text) => {
+            if (role !== "writer")
+                return;
+            void deps.clipboard.write(text).then((ok) => {
+                if (!ok || done)
+                    return;
+                status?.flash(`✓ Copied ${[...text].length} characters`);
+                opts.onCopied?.(text);
+            });
+        } : undefined;
+        let stream = new StreamFilter(onClipboard);
         let injections = [];
         let status = null;
         let pollTimer = null;
@@ -264,7 +277,7 @@ export function attach(deps, session, opts = {}) {
             const sock = deps.openWs(wsUrlFor(deps.host, session.id), [TTY_SUBPROTOCOL, ticket]);
             sock.binaryType = "arraybuffer";
             ws = sock;
-            stream = new StreamFilter();
+            stream = new StreamFilter(onClipboard);
             askedTakeover = false;
             takeoverPending = false;
             sock.onopen = () => {

package/dist/cli.js

@@ -10,7 +10,7 @@ import { createInterface } from "node:readline/promises";
 import { makeApi } from "./api.js";
 import { attach, RESTORE_TERMINAL } from "./attach.js";
 import { CliError, currentSession, discover, loginFromTokens, normalizeHost, orgsOf, pollDevice, revoke, startDevice, whoOf, } from "./auth.js";
-import { readClipboardImage } from "./clipboard.js";
+import { clipboardWriter, readClipboardImage, writeClipboard } from "./clipboard.js";
 import { CubeSpinner } from "./cube.js";
 import { ensureRunning } from "./resume.js";
 import { launchTui } from "./tui/launch.js";
@@ -44,6 +44,9 @@ While attached, every key goes to the session except:
   Ctrl-]   detach (the session keeps running)
   Ctrl-V   paste the image on your clipboard (uploaded, then its path is typed in)
 
+To copy, drag over text: it is on your clipboard the moment you let go (the session's tmux does the
+selecting). Claude Code's own copy, like the c on its login URL, lands there too.
+
 If the connection drops, nothing reconnects on its own: you are told why, and r reconnects.
 
 In the split view: ⏎ or a click opens a session, Ctrl-] in a session jumps back to the list, l / m
@@ -241,6 +244,7 @@ async function cmdAttach(a) {
             stdout: process.stdout,
             stderr: process.stderr,
             readClipboardImage: () => readClipboardImage(),
+            clipboard: copier(),
         }, row, { view, signal: ac.signal, status: a.flags.has("no-status") ? false : undefined });
         if (result.outcome !== "disconnected" || ac.signal.aborted) {
             process.stderr.write(`[cubes] ${result.message}\n`);
@@ -252,6 +256,11 @@ async function cmdAttach(a) {
         row = await api.get(`/sessions/${encodeURIComponent(row.id)}`);
     }
 }
+/** What the session copies goes to this machine's clipboard, when it has a way to write one. */
+export function copier() {
+    const cmd = clipboardWriter();
+    return cmd ? { write: (text) => writeClipboard(cmd, text) } : null;
+}
 /** One keystroke, raw: true when it is one of `yes`. */
 function keyIs(prompt, yes) {
     if (!process.stdin.isTTY)

package/dist/clipboard.js

@@ -3,7 +3,7 @@
 // macOS: AppleScript coerces whatever the pasteboard holds (a screenshot, an image copied from a
 // browser) to PNG and writes it to a temp file. Linux: wl-paste on Wayland, xclip on X11. Anything
 // else, or no image there, is null - and the caller then sends Ctrl-V through untouched.
-import { execFile } from "node:child_process";
+import { execFile, spawn, spawnSync } from "node:child_process";
 import { mkdtempSync, readFileSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
@@ -65,3 +65,34 @@ export async function readClipboardImage(platform = process.platform, env = proc
         return linux(env);
     return null;
 }
+// ── WRITING: what the session copies (OSC 52) lands on THIS machine's clipboard ─────────────────────
+/** The command that writes the clipboard here, or null when there is none to use. */
+export function clipboardWriter(platform = process.platform, env = process.env) {
+    const has = (cmd) => spawnSync("sh", ["-c", `command -v ${cmd}`], { stdio: "ignore" }).status === 0;
+    if (platform === "darwin")
+        return ["pbcopy"];
+    if (platform === "win32")
+        return ["clip"];
+    if (platform === "linux") {
+        if (env.WAYLAND_DISPLAY && has("wl-copy"))
+            return ["wl-copy"];
+        if (env.DISPLAY && has("xclip"))
+            return ["xclip", "-selection", "clipboard", "-in"];
+        if (env.DISPLAY && has("xsel"))
+            return ["xsel", "--clipboard", "--input"];
+    }
+    return null;
+}
+export function writeClipboard(cmd, text) {
+    return new Promise((resolve) => {
+        try {
+            const child = spawn(cmd[0], cmd.slice(1), { stdio: ["pipe", "ignore", "ignore"] });
+            child.on("error", () => resolve(false));
+            child.on("exit", (code) => resolve(code === 0));
+            child.stdin.end(text);
+        }
+        catch {
+            resolve(false);
+        }
+    });
+}

package/dist/termstatus.js

@@ -30,6 +30,22 @@ export function clean(s, max = 120) {
     const t = s.replace(/[\x00-\x1f\x7f-\x9f]/g, " ").replace(/\s+/g, " ").trim();
     return t.length > max ? t.slice(0, max - 1) + "…" : t;
 }
+/** Largest OSC 52 we will hold (base64): a copy, not a file transfer. Past it the copy is dropped. */
+const CLIP_MAX = 4 * 1024 * 1024;
+/** The text an OSC 52 body (`c;<base64>`) carries, or null for a READ request (`?`), which we never
+ *  answer - a session asking for the person's clipboard gets nothing. */
+export function decodeOsc52(body) {
+    const semi = body.indexOf(";");
+    const data = semi >= 0 ? body.slice(semi + 1) : body;
+    if (!data || data === "?")
+        return null;
+    try {
+        return Buffer.from(data, "base64").toString("utf8");
+    }
+    catch {
+        return null;
+    }
+}
 /**
  * Passes the session's output through, minus the two things that would fight us for the title -
  * OSC 0/1/2 (set title) and CSI 22/23 t (title push/pop, which the session's tmux sends on attach and
@@ -37,10 +53,20 @@ export function clean(s, max = 120) {
  * safe to write a sequence of our own.
  */
 export class StreamFilter {
+    onClipboard;
     st = "ground";
     seq = []; // the CSI or OSC-prefix being decided
     utf8Left = 0;
     oscEsc = false; // saw ESC inside a string, waiting for '\'
+    clip = [];
+    /**
+     * `onClipboard`: when given, an OSC 52 (set clipboard) is taken OUT of the stream and its text
+     * handed over instead - the CLI puts it on the person's clipboard itself, which works whether or not
+     * their terminal honours OSC 52. Without it, OSC 52 passes through like any other OSC.
+     */
+    constructor(onClipboard) {
+        this.onClipboard = onClipboard;
+    }
     get safe() {
         return this.st === "ground" && this.utf8Left === 0;
     }
@@ -112,10 +138,12 @@ export class StreamFilter {
                     const ends = b === 0x07 || b === 0x1b;
                     if (b === 0x3b || ends || this.seq.length > 8) {
                         const num = String.fromCharCode(...this.seq.slice(2));
-                        const title = /^[012]$/.test(num);
+                        const clip = num === "52" && !!this.onClipboard;
+                        const title = /^[012]$/.test(num) || clip; // both are ours, neither reaches the terminal
                         if (!title)
                             out.push(...this.seq);
                         this.seq = [];
+                        this.clip = [];
                         if (ends) {
                             if (b === 0x07) {
                                 if (!title)
@@ -125,14 +153,14 @@ export class StreamFilter {
                             else {
                                 if (!title)
                                     out.push(b);
-                                this.st = title ? "oscDrop" : "str";
+                                this.st = clip ? "oscClip" : title ? "oscDrop" : "str";
                                 this.oscEsc = true;
                             }
                         }
                         else {
                             if (!title)
                                 out.push(b);
-                            this.st = title ? "oscDrop" : "str";
+                            this.st = clip ? "oscClip" : title ? "oscDrop" : "str";
                             this.oscEsc = false;
                         }
                     }
@@ -141,6 +169,20 @@ export class StreamFilter {
                     }
                     break;
                 }
+                case "oscClip": {
+                    if (this.oscEsc && b === 0x5c) {
+                        this.endClip();
+                        break;
+                    } // ST = ESC \
+                    if (b === 0x07) {
+                        this.endClip();
+                        break;
+                    }
+                    this.oscEsc = b === 0x1b;
+                    if (!this.oscEsc && this.clip.length < CLIP_MAX)
+                        this.clip.push(b);
+                    break;
+                }
                 case "oscDrop":
                 case "str": {
                     const keep = this.st === "str";
@@ -160,6 +202,16 @@ export class StreamFilter {
         }
         return Uint8Array.from(out);
     }
+    endClip() {
+        this.st = "ground";
+        this.oscEsc = false;
+        // Buffer, not String.fromCharCode(...bytes): a spread of a large copy overflows the argument limit.
+        const body = this.clip.length < CLIP_MAX ? Buffer.from(this.clip).toString("latin1") : "";
+        this.clip = [];
+        const text = body ? decodeOsc52(body) : null;
+        if (text)
+            this.onClipboard?.(text);
+    }
 }
 function stateOf(r) {
     if (r.status !== "running")
@@ -206,6 +258,16 @@ export class TermStatus {
         const glyph = this.state === "working" ? WORKING : this.state === "waiting" ? WAITING : IDLE;
         return `${glyph} ${clean(this.row.title || "Cubes session", 80)}`;
     }
+    flashTimer = null;
+    /** A moment's word in the tab title ("✓ Copied 42 characters"), then the title it had. */
+    flash(text, ms = 1500) {
+        if (this.flashTimer)
+            clearTimeout(this.flashTimer);
+        this.emit(`\x1b]0;${clean(text, 80)}\x07`);
+        this.shown = "";
+        this.flashTimer = setTimeout(() => { this.flashTimer = null; this.setTitle(); }, ms);
+        this.flashTimer.unref?.();
+    }
     /** Only when it changed: the activity is re-read every few seconds, and most reads change nothing. */
     setTitle() {
         const t = this.title();

package/dist/tui/paneApp.js

@@ -7,7 +7,7 @@
 import { makeApi } from "../api.js";
 import { attach } from "../attach.js";
 import { currentSession } from "../auth.js";
-import { readClipboardImage } from "../clipboard.js";
+import { clipboardWriter, readClipboardImage, writeClipboard } from "../clipboard.js";
 import { CubeSpinner, cubeSize } from "../cube.js";
 import { ensureRunning } from "../resume.js";
 import { statusOf } from "./model.js";
@@ -102,6 +102,7 @@ const OUTCOME_WORDS = {
 };
 async function sessionPane(id) {
     const api = makeApi(currentSession());
+    const copyCmd = clipboardWriter();
     setSessionOption("@cubes_current", id);
     let row = { id, title: null, status: "running", created_at: "" };
     setHeader(row, { glyph: "◌", color: 80, label: "connecting" });
@@ -122,8 +123,13 @@ async function sessionPane(id) {
                 stdout: out,
                 stderr: out,
                 readClipboardImage: () => readClipboardImage(),
+                clipboard: copyCmd ? { write: (text) => writeClipboard(copyCmd, text) } : null,
             }, row, {
                 onDetachKey: focusList,
+                onCopied: (text) => {
+                    setPaneOption("@cubes_header", `#[fg=colour78]✓ Copied ${[...text].length} characters to your clipboard#[default]`);
+                    setTimeout(() => setHeader(row), 1500);
+                },
                 status: { onRow: (r) => { row = { ...row, ...r }; setHeader(row); } },
             });
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hellix-ai/cubes",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "Attach to your Cubes sessions from your own terminal (Warp, iTerm, Ghostty, anything).",
   "type": "module",
   "bin": {