cc-session-control 0.4.0__tar.gz

cc_session_control-0.4.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 dzshzx
+
+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.

cc_session_control-0.4.0/PKG-INFO

@@ -0,0 +1,115 @@
+Metadata-Version: 2.4
+Name: cc-session-control
+Version: 0.4.0
+Summary: TUI manager for Claude Code sessions and Remote Control
+Author: dzshzx
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/dzshzx/cc-session-control
+Project-URL: Repository, https://github.com/dzshzx/cc-session-control
+Project-URL: Issues, https://github.com/dzshzx/cc-session-control/issues
+Keywords: claude-code,session-manager,tui,remote-control,urwid
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: User Interfaces
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: urwid>=2.0.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Dynamic: license-file
+
+# cc-session-control
+
+TUI manager for [Claude Code](https://claude.ai/code) sessions and Remote Control.
+
+**CLI command: `csctl`**
+
+## Features
+
+- **Sessions Tab** — View, resume, terminate, and delete Claude Code sessions across all projects
+- **Remote Control Tab** — Start/stop RC servers per project, toggle auto-start, show running/stopped/dead states
+- **Cleanup Tab** — Prune empty/short sessions, sweep orphan artifact directories
+
+Built with [urwid](https://urwid.org/).
+
+> **UI language:** Simplified Chinese (notifications and status text). CLI output is in English.
+
+## Requirements
+
+- Python 3.12+
+- [Claude Code](https://claude.ai/code) CLI installed and authenticated
+- tmux (for Remote Control management)
+- Linux / WSL (macOS support is partial — `/proc`-based liveness detection is Linux-only)
+
+## Installation
+
+> **Coming soon to PyPI.** The package is not published yet. Until the first
+> release lands, install from GitHub (see *Latest `master` build* below). Once
+> published, the commands below will work.
+
+Install the latest published release:
+
+```bash
+uv tool install cc-session-control
+# or
+pipx install cc-session-control
+```
+
+Upgrade later with `uv tool upgrade cc-session-control` (or `pipx upgrade
+cc-session-control`).
+
+### Latest `master` build
+
+Until the package is on PyPI — or to try the newest `master` before it is
+released — install from GitHub:
+
+```bash
+uv tool install --reinstall git+https://github.com/dzshzx/cc-session-control.git
+```
+
+`csctl` manages the Claude Code state on the machine where it is installed: the
+local `~/.claude`, local `tmux`, and local workspace. Install it separately on
+each machine whose sessions you want to manage. For working *on* the code
+instead of using it, see [CONTRIBUTING.md](CONTRIBUTING.md).
+
+## Usage
+
+```bash
+# Open TUI
+csctl
+
+# Remote Control management (no TUI)
+csctl rc status          # Show all projects and RC status
+csctl rc add .           # Add current project to RC list and start
+csctl rc add myproject   # Add by name
+csctl rc rm myproject    # Remove and stop
+csctl rc up              # Start all listed projects
+csctl rc stop all        # Stop all RC servers
+csctl rc list            # Show auto-start list
+
+# Session cleanup
+csctl prune                          # Dry run: show stats
+csctl prune --max-prompts 1 --apply  # Delete sessions with ≤1 prompt
+
+# Options
+csctl --workspace ~/projects   # Override workspace root
+csctl --version
+```
+
+## Configuration
+
+| Environment Variable | Default | Description |
+|---|---|---|
+| `CSCTL_WORKSPACE` | `~/workspace` | Workspace root directory |
+| `CSCTL_RC_SESSION` | `rc` | tmux session name for RC servers |
+| `CSCTL_RC_STAGGER` | `2` | Seconds between starting RC servers |
+| `XDG_CONFIG_HOME` | `~/.config` | Config directory base |
+
+RC auto-start list is stored at `$XDG_CONFIG_HOME/csctl/rc-enabled`.
+
+## License
+
+MIT

cc_session_control-0.4.0/README.md

@@ -0,0 +1,92 @@
+# cc-session-control
+
+TUI manager for [Claude Code](https://claude.ai/code) sessions and Remote Control.
+
+**CLI command: `csctl`**
+
+## Features
+
+- **Sessions Tab** — View, resume, terminate, and delete Claude Code sessions across all projects
+- **Remote Control Tab** — Start/stop RC servers per project, toggle auto-start, show running/stopped/dead states
+- **Cleanup Tab** — Prune empty/short sessions, sweep orphan artifact directories
+
+Built with [urwid](https://urwid.org/).
+
+> **UI language:** Simplified Chinese (notifications and status text). CLI output is in English.
+
+## Requirements
+
+- Python 3.12+
+- [Claude Code](https://claude.ai/code) CLI installed and authenticated
+- tmux (for Remote Control management)
+- Linux / WSL (macOS support is partial — `/proc`-based liveness detection is Linux-only)
+
+## Installation
+
+> **Coming soon to PyPI.** The package is not published yet. Until the first
+> release lands, install from GitHub (see *Latest `master` build* below). Once
+> published, the commands below will work.
+
+Install the latest published release:
+
+```bash
+uv tool install cc-session-control
+# or
+pipx install cc-session-control
+```
+
+Upgrade later with `uv tool upgrade cc-session-control` (or `pipx upgrade
+cc-session-control`).
+
+### Latest `master` build
+
+Until the package is on PyPI — or to try the newest `master` before it is
+released — install from GitHub:
+
+```bash
+uv tool install --reinstall git+https://github.com/dzshzx/cc-session-control.git
+```
+
+`csctl` manages the Claude Code state on the machine where it is installed: the
+local `~/.claude`, local `tmux`, and local workspace. Install it separately on
+each machine whose sessions you want to manage. For working *on* the code
+instead of using it, see [CONTRIBUTING.md](CONTRIBUTING.md).
+
+## Usage
+
+```bash
+# Open TUI
+csctl
+
+# Remote Control management (no TUI)
+csctl rc status          # Show all projects and RC status
+csctl rc add .           # Add current project to RC list and start
+csctl rc add myproject   # Add by name
+csctl rc rm myproject    # Remove and stop
+csctl rc up              # Start all listed projects
+csctl rc stop all        # Stop all RC servers
+csctl rc list            # Show auto-start list
+
+# Session cleanup
+csctl prune                          # Dry run: show stats
+csctl prune --max-prompts 1 --apply  # Delete sessions with ≤1 prompt
+
+# Options
+csctl --workspace ~/projects   # Override workspace root
+csctl --version
+```
+
+## Configuration
+
+| Environment Variable | Default | Description |
+|---|---|---|
+| `CSCTL_WORKSPACE` | `~/workspace` | Workspace root directory |
+| `CSCTL_RC_SESSION` | `rc` | tmux session name for RC servers |
+| `CSCTL_RC_STAGGER` | `2` | Seconds between starting RC servers |
+| `XDG_CONFIG_HOME` | `~/.config` | Config directory base |
+
+RC auto-start list is stored at `$XDG_CONFIG_HOME/csctl/rc-enabled`.
+
+## License
+
+MIT

cc_session_control-0.4.0/pyproject.toml

@@ -0,0 +1,38 @@
+[build-system]
+requires = ["setuptools>=68.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "cc-session-control"
+dynamic = ["version"]
+description = "TUI manager for Claude Code sessions and Remote Control"
+requires-python = ">=3.12"
+license = "MIT"
+readme = "README.md"
+authors = [{ name = "dzshzx" }]
+keywords = ["claude-code", "session-manager", "tui", "remote-control", "urwid"]
+dependencies = ["urwid>=2.0.0"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Environment :: Console",
+    "Operating System :: POSIX :: Linux",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Software Development :: User Interfaces",
+]
+
+[project.urls]
+Homepage = "https://github.com/dzshzx/cc-session-control"
+Repository = "https://github.com/dzshzx/cc-session-control"
+Issues = "https://github.com/dzshzx/cc-session-control/issues"
+
+[project.scripts]
+csctl = "cc_session_control.cli:main"
+
+[project.optional-dependencies]
+dev = ["pytest>=7.0"]
+
+[tool.setuptools.dynamic]
+version = { attr = "cc_session_control.__version__" }
+
+[tool.setuptools.packages.find]
+where = ["src"]

cc_session_control-0.4.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

cc_session_control-0.4.0/src/cc_session_control/__init__.py

@@ -0,0 +1,3 @@
+"""cc-session-control — TUI manager for Claude Code sessions and Remote Control."""
+
+__version__ = "0.4.0"

cc_session_control-0.4.0/src/cc_session_control/__main__.py

@@ -0,0 +1,5 @@
+"""Allow running as `python -m cc_session_control`."""
+
+from .cli import main
+
+main()

cc_session_control-0.4.0/src/cc_session_control/actions/agent_ops.py

@@ -0,0 +1,201 @@
+"""Background-agent lifecycle actions (R4 / Phase 6).
+
+The persistent truth for a background agent lives in `jobs/<short>/state.json`
+(registry.read_agent_jobs → AgentJob); it carries NO pid. So a live worker's host
+pid is resolved by JOINing the job's sid back to `sessions/<pid>.json`
+(`job_host`) — a live worker with no sessions file is therefore unstoppable, a
+documented orphan risk surfaced in `HELP`.
+
+Capability red lines honoured here:
+  - respawn/takeover never replace the csctl process (respawn spawns a tmux
+    window; takeover hands a Session to the existing `do_resume` path run AFTER
+    the UI loop exits).
+  - stop only signals a confirmed-live joined host pid; killing a
+    `--remote-control`/bg worker does not always fully reap it (orphan risk).
+  - destructive ops (remove/stop) refuse when "current" can't be determined
+    (no `/proc`, R10) so they never blind-hit csctl's own session.
+
+This is an action module: internals are English, but the user-facing label/help
+constants the (Phase 7) background view reads are Simplified Chinese.
+"""
+
+from __future__ import annotations
+
+import os
+import shlex
+import signal
+import time
+from dataclasses import replace
+
+from ..config import cfg
+from ..data import cleanup, liveness, proc, rc, registry
+from ..models import AgentJob, Session
+
+# --- User-facing labels/help (Simplified Chinese, read by the Phase 7 view) ---
+
+TAKEOVER_LABEL = "接回"
+
+# Unified verb table (matches Sessions/RC): Enter/o=接回(primary), s=停止(kill a
+# live thing), d=删除, R=重启(respawn). `r`=刷新 lives in the App-level footer
+# prefix now, so it is NOT repeated here; separators are ` · ` like the other tabs.
+KEYHINTS = "Enter/o 接回 · s 停止 · d 删除 · w 查看 · R 重启"
+
+# Orphan-process risk (R4.5 red line): stop only kills the host pid joined from
+# the sessions registry, killing a --remote-control/bg worker does not always
+# fully reap it, and a live worker with no sessions file can't be located at all.
+HELP = (
+    "后台 agent 生命周期：\n"
+    "  Enter/o 接回(拉回前台，复用 resume；接运行中的 agent 会先确认接管)  w 查看 timeline(只读)\n"
+    "  R 重启(respawn)  d 删除(仅已结束)  s 停止(仅运行中，需确认)  r 刷新\n"
+    "停止/孤儿风险：停止只能杀经 sessions 文件 join 到的 host pid；"
+    "杀 --remote-control/后台 agent 不一定彻底回收，可能残留孤儿进程，需手动确认；"
+    "找不到运行中的后台 agent 的 host pid 时无法停止。"
+)
+
+
+# --- host-pid join (shared by stop_job, remove_job, and the view) -------------
+
+def job_host(job: AgentJob) -> tuple[int | None, bool]:
+    """Resolve a background job's host pid + liveness — `(pid, alive)`.
+
+    `state.json` has no pid, so the worker's pid is JOINed from
+    `sessions/<pid>.json` on `job.sid` (a bg session proc; `kind` is typically
+    "bg"). Prefers a `/proc`-confirmed live match (so `alive=True` is trustworthy
+    and defeats pid reuse via `procStart`); falls back to the first sid match
+    with `alive=False`. Returns `(None, False)` when no sessions file exists for
+    the sid — that live worker is unstoppable (documented orphan risk).
+
+    Injects `/proc` liveness onto the registry rows, then defers to the single
+    pure join `registry.host_pid_for_sid` (shared with `snapshot._enrich_jobs`).
+    """
+    procs = [
+        replace(sp, proc_alive=proc.pid_alive(sp.pid, sp.proc_start))
+        for sp in registry.read_session_procs()
+    ]
+    return registry.host_pid_for_sid(job.sid, procs)
+
+
+# --- respawn ------------------------------------------------------------------
+
+def respawn_cmd(job: AgentJob) -> str:
+    """The exact relaunch command: `claude --resume <resume_sid> <flags> --bg`.
+
+    Pure string build via `shlex.join` (split from `respawn` so it can be copied
+    to the clipboard / asserted in tests). `respawn_flags` are reused verbatim
+    from the recorded job state.
+    """
+    args = ["claude", "--resume", job.resume_sid, *job.respawn_flags, "--bg"]
+    return shlex.join(args)
+
+
+def _job_window(job: AgentJob) -> str:
+    """tmux window name for a respawned agent (name or short, suffixed)."""
+    base = (job.name or "bg").strip() or "bg"
+    return f"{base}-{job.short[:8]}"
+
+
+def respawn(job: AgentJob) -> str:
+    """Relaunch a background agent in tmux; returns the exact command string.
+
+    Runs `respawn_cmd(job)` in the shared tmux session (`cfg.tmux_session`) so it
+    outlives the terminal — it does NOT os.exec/replace the csctl process. The
+    returned string also feeds the clipboard `y`-style key.
+    """
+    cmd = respawn_cmd(job)
+    rc.run_in_tmux(cfg.tmux_session, _job_window(job), cmd)
+    return cmd
+
+
+# --- remove (settled agents only) ---------------------------------------------
+
+def remove_job(job: AgentJob) -> bool:
+    """Remove a SETTLED background agent: `jobs/<short>/` + its sid artifacts.
+
+    Returns True iff the job dir was removed. Refuses (False) for a LIVE worker
+    (`job_host` reports alive) and when "current" can't be determined (no
+    `/proc`, R10) — destructive, must not run blind.
+    """
+    if not proc.current_determinable():
+        return False
+    _, alive = job_host(job)
+    if alive:
+        return False
+    job_dir = os.path.join(str(cfg.jobs_dir), job.short)
+    removed = cleanup._remove_path(job_dir)
+    # Reuse cleanup's artifact-path helper / remover: it returns the sid-keyed
+    # dirs (session-env/file-history/tasks/uploads) plus jobs/<sid[:8]> (which
+    # usually equals job_dir — a second remove is a harmless no-op), so the job's
+    # session leaves no orphan artifacts behind.
+    for path in cleanup._session_artifact_paths(job.sid):
+        cleanup._remove_path(path)
+    return removed
+
+
+# --- watch (read-only) --------------------------------------------------------
+
+def watch(job: AgentJob) -> str | None:
+    """Path to the job's read-only `jobs/<short>/timeline.jsonl`, or None.
+
+    Pure lookup, no mutation — returns the path only when the file exists so the
+    view can fall back gracefully (R4.4 read-only watch).
+    """
+    path = os.path.join(str(cfg.jobs_dir), job.short, "timeline.jsonl")
+    return path if os.path.isfile(path) else None
+
+
+# --- resume takeover (reuses the existing foreground resume path) -------------
+
+def resume_takeover(job: AgentJob) -> Session:
+    """Adapt a background job into a `Session` for the EXISTING resume path.
+
+    Bringing a bg session to the foreground is just a resume of its
+    `resume_sid`, so this returns a Session the view feeds to the SAME
+    `app.exit_with_resume` → `do_resume` pipeline used for foreground sessions —
+    all kill/exec/`_resume_plan` logic is reused, none duplicated (R4.4 takeover).
+    `pid`/`alive` come from the host join so a live worker is killed first
+    (resume = takeover); `current` is computed so the launching session stays
+    protected. Does NOT itself replace the csctl process.
+    """
+    pid, alive = job_host(job)
+    current = bool(pid) and pid in proc.ancestor_pids()
+    return Session(
+        sid=job.resume_sid,
+        cwd=job.cwd,
+        label=job.name or job.short,
+        mtime=0.0,
+        prompts=0,
+        pid=pid,
+        alive=alive,
+        current=current,
+        source="bg",
+        agent_short=job.short,
+    )
+
+
+# --- stop (live workers only) -------------------------------------------------
+
+def stop_job(job: AgentJob) -> bool:
+    """Stop a LIVE background worker via its joined host pid. True iff signalled.
+
+    The host pid is JOINed from `sessions/<pid>.json` (`job_host`); only a
+    confirmed-live pid is killed — a worker with no sessions file is unstoppable
+    (no-op False, orphan risk). Refuses when "current" can't be determined (no
+    `/proc`, R10). Owns the liveness-cache invalidation (like terminate). Killing
+    does not always fully reap a `--remote-control`/bg worker (orphan risk, see
+    `HELP`).
+    """
+    if not proc.current_determinable():
+        return False
+    pid, alive = job_host(job)
+    if not alive or not pid:
+        return False
+    try:
+        os.kill(pid, signal.SIGTERM)
+    except ProcessLookupError:
+        liveness.invalidate_cache()  # already gone — liveness changed
+        return True
+    except Exception:
+        return False
+    time.sleep(1)
+    liveness.invalidate_cache()
+    return True

cc_session_control-0.4.0/src/cc_session_control/actions/session_ops.py

@@ -0,0 +1,150 @@
+"""Session operations: resume, terminate, delete, clipboard."""
+
+from __future__ import annotations
+
+import os
+import shlex
+import signal
+import time
+
+from .. import clipboard
+from ..config import cfg
+from ..data import proc, rc
+from ..data.liveness import invalidate_cache
+from ..models import Session
+
+
+def terminate_session(s: Session) -> bool:
+    """Send SIGTERM and own the liveness-cache invalidation.
+
+    Terminating is the one session op that changes `claude agents` liveness,
+    so it invalidates the alive_map cache itself — callers no longer have to
+    remember to. (delete/cleanup only touch already-dead sessions, so they
+    don't.)
+
+    R10: refuses (returns False) when "current" can't be determined (no
+    `/proc`) — we can't prove `s` is not the launching session, so a SIGTERM
+    here could hit csctl's own session.
+    """
+    if not proc.current_determinable():
+        return False
+    if not s.pid:
+        return False
+    try:
+        os.kill(s.pid, signal.SIGTERM)
+    except ProcessLookupError:
+        invalidate_cache()  # already gone — liveness changed
+        return True
+    except Exception:
+        return False
+    time.sleep(1)
+    invalidate_cache()
+    return True
+
+
+def _resume_plan(s: Session, fork: bool = False) -> tuple[str, list[str], bool]:
+    """Shared resume recipe: the cwd to enter, the claude argv, and whether
+    to kill the old session first.
+
+    Returns (cwd, args, should_kill). Unified kill semantics: a fork is a copy
+    and leaves the original running, while a plain resume takes the session
+    over — so we kill only when it is alive, not the current session, and we
+    are NOT forking. `resume_cmd` and `do_resume` both obey this single
+    decision; they must not re-derive it.
+    """
+    args = ["claude", "--resume", s.sid]
+    if fork:
+        args.append("--fork-session")
+    should_kill = s.alive and not s.current and not fork
+    return s.cwd, args, should_kill
+
+
+def would_take_over(s: Session, fork: bool = False) -> bool:
+    """Whether resuming/relaunching `s` would first kill a live process (takeover).
+
+    The single source of the "needs confirmation" decision for the UI: it reads
+    `_resume_plan`'s `should_kill` so views never re-derive `s.alive and not
+    s.current` themselves (CLAUDE.md: should_kill is single-point — re-derivation
+    was the old divergence). `do_resume`/`relaunch_in_tmux` and the confirm gate
+    thus agree by construction.
+    """
+    return _resume_plan(s, fork)[2]
+
+
+def resume_cmd(s: Session, fork: bool = False) -> str:
+    cwd, args, should_kill = _resume_plan(s, fork)
+    parts: list[str] = []
+    if should_kill and s.pid:  # never emit a bare `kill None` (L7)
+        parts.append(f"kill {s.pid} && sleep 1")
+    if cwd:
+        parts.append(f"cd {shlex.quote(cwd)}")
+    parts.append(shlex.join(args))
+    return " && ".join(parts)
+
+
+def do_resume(s: Session, fork: bool = False) -> None:
+    """chdir + (kill if needed) + exec claude. Does not return on success.
+
+    R10: when a takeover kill is required but "current" can't be determined (no
+    `/proc`), refuse — print a message and return WITHOUT killing or exec'ing, so
+    we never SIGTERM the launching session (every pid looks dead off `/proc`).
+    """
+    cwd, args, should_kill = _resume_plan(s, fork)
+    if should_kill:
+        if not proc.current_determinable():
+            print(
+                "Refused: '/proc' unavailable — cannot determine the current "
+                "session, so the old process can't be safely killed (R10)."
+            )
+            return
+        try:
+            os.kill(s.pid, signal.SIGTERM)
+        except Exception:
+            pass
+        time.sleep(1)
+    if cwd and os.path.isdir(cwd):
+        os.chdir(cwd)
+    os.execvp("claude", args)
+
+
+def _rc_name(s: Session) -> str:
+    """Remote-control label (shown in claude.ai/code) for a relaunched session."""
+    base = s.cwd.rstrip("/").rsplit("/", 1)[-1] if s.cwd else ""
+    return f"{base or 'session'}-{s.sid[:8]}"
+
+
+def tmux_resume_cmd(s: Session, fork: bool = False) -> str:
+    """Shell command that resumes the session under remote control."""
+    cwd, args, _ = _resume_plan(s, fork)
+    args = args + ["--remote-control", _rc_name(s)]
+    line = shlex.join(args)
+    return f"cd {shlex.quote(cwd)} && {line}" if cwd else line
+
+
+def relaunch_in_tmux(s: Session, fork: bool = False) -> bool:
+    """Relaunch a session as `claude --resume … --remote-control …` inside a
+    tmux window, so it outlives the terminal and is remotely controllable.
+
+    A live, non-current session is taken over (its old pid is killed first and
+    the liveness cache invalidated, like terminate); a fork leaves the original
+    running. csctl is NOT replaced — it just spawns the tmux window.
+
+    R10: when a takeover kill is required but "current" can't be determined (no
+    `/proc`), refuse (return False, do not kill or relaunch) — we can't prove `s`
+    is not the launching session.
+    """
+    _, _, should_kill = _resume_plan(s, fork)
+    if should_kill and s.pid:
+        if not proc.current_determinable():
+            return False
+        try:
+            os.kill(s.pid, signal.SIGTERM)
+        except Exception:
+            pass
+        time.sleep(1)
+        invalidate_cache()
+    return rc.run_in_tmux(cfg.tmux_session, _rc_name(s), tmux_resume_cmd(s, fork))
+
+
+def to_clipboard(text: str) -> bool:
+    return clipboard.copy(text)