agentwire-dev 1.51.0__tar.gz → 1.52.0__tar.gz

{agentwire_dev-1.51.0 → agentwire_dev-1.52.0}/.gitignore

@@ -60,3 +60,6 @@ snapshot_report.html
 
 # Node
 node_modules/
+
+# Private security-audit findings (never publish — see SECURITY.md)
+/security-audit/

{agentwire_dev-1.51.0 → agentwire_dev-1.52.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentwire-dev
-Version: 1.51.0
+Version: 1.52.0
 Summary: Multi-session voice web interface for AI coding agents
 Project-URL: Homepage, https://agentwire.dev
 Project-URL: Repository, https://github.com/dotdevdotdev/agentwire-dev

{agentwire_dev-1.51.0 → agentwire_dev-1.52.0}/agentwire/__init__.py

@@ -1,3 +1,3 @@
 """AgentWire - Multi-session voice web interface for AI coding agents."""
 
-__version__ = "1.51.0"
+__version__ = "1.52.0"

{agentwire_dev-1.51.0 → agentwire_dev-1.52.0}/agentwire/agents/tmux.py

@@ -236,11 +236,11 @@ class TmuxAgent(AgentBackend):
                 # Use base64 + load-buffer on remote to avoid PTY flooding
                 import base64
                 encoded = base64.b64encode(text.encode()).decode()
+                # Pipe straight into the tmux buffer — no on-disk temp that could
+                # expose message content or be pre-planted on the remote host
                 cmd = (
-                    f"echo {shlex.quote(encoded)} | base64 -d > /tmp/aw-send-$$.txt && "
-                    f"tmux load-buffer /tmp/aw-send-$$.txt && "
+                    f"echo {shlex.quote(encoded)} | base64 -d | tmux load-buffer - && "
                     f"tmux paste-buffer -t {shlex.quote(session_name)} && "
-                    f"rm -f /tmp/aw-send-$$.txt && "
                     f"sleep 0.2 && "
                     f"tmux send-keys -t {shlex.quote(session_name)} Enter"
                 )

{agentwire_dev-1.51.0 → agentwire_dev-1.52.0}/agentwire/config.py

@@ -74,6 +74,12 @@ class ServerConfig:
     # bearer token then transits in cleartext. Required to start a non-loopback
     # bind without TLS — the BYO-tunnel case where the tunnel terminates TLS.
     allow_insecure: bool = False
+    # Emit HTTP Strict-Transport-Security. Leave OFF for self-signed /
+    # localhost / LAN — HSTS + a self-signed cert locks the browser out of the
+    # portal if the cert ever rotates. Enable ONLY when serving a real
+    # (CA-signed) cert directly. Behind Cloudflare Tunnel / a reverse proxy,
+    # set HSTS at the edge instead.
+    hsts: bool = False
 
 
 @dataclass
@@ -590,6 +596,7 @@ def _dict_to_config(data: dict) -> Config:
         # "" (explicit disable) must survive — don't collapse it to None.
         auth_token=server_data.get("auth_token"),
         allow_insecure=bool(server_data.get("allow_insecure", False)),
+        hsts=bool(server_data.get("hsts", False)),
     )
 
     # Projects

{agentwire_dev-1.51.0 → agentwire_dev-1.52.0}/agentwire/inbox.py

@@ -30,6 +30,7 @@ from __future__ import annotations
 import errno
 import json
 import os
+import re
 import time
 import uuid
 from dataclasses import dataclass
@@ -148,8 +149,28 @@ def _short_uuid() -> str:
     return uuid.uuid4().hex[:6]
 
 
+# Session names are agent-controlled (msg_send `to`), so they must never be
+# able to path-traverse out of INBOX_ROOT. Worktree session names legitimately
+# contain `/` (they nest one directory level per segment — see module
+# docstring), so segments are validated individually; `..`, absolute paths,
+# and empty names/segments are rejected.
+_SESSION_RE = re.compile(r"^[A-Za-z0-9._@-]+(?:/[A-Za-z0-9._@-]+)*$")
+
+
+def _validate_session(session: str) -> str:
+    if not session or not _SESSION_RE.match(session) or ".." in session.split("/"):
+        raise ValueError(f"invalid session name: {session!r}")
+    return session
+
+
 def session_dir(session: str) -> Path:
-    return INBOX_ROOT / session
+    _validate_session(session)
+    path = INBOX_ROOT / session
+    # Belt and braces: the regex already forbids traversal, but confine the
+    # result to INBOX_ROOT so a validator regression can't escape it.
+    if not path.resolve().is_relative_to(INBOX_ROOT.resolve()):
+        raise ValueError(f"invalid session name: {session!r}")
+    return path
 
 
 def dead_dir(session: str) -> Path:
@@ -440,7 +461,7 @@ def resolve_targets(to: str, sender: "str | None") -> list[str]:
     """
     if to == BROADCAST_TOKEN:
         return [s for s in _live_agent_sessions() if s != sender]
-    return [to]
+    return [_validate_session(to)]
 
 
 def enqueue(

{agentwire_dev-1.51.0 → agentwire_dev-1.52.0}/agentwire/listen.py

@@ -5,6 +5,7 @@ import shutil
 import signal
 import subprocess
 import sys
+import tempfile
 import time
 from pathlib import Path
 
@@ -57,18 +58,53 @@ AGENTWIRE_PATH = _find_executable("agentwire", [
     str(Path.home() / ".local" / "bin" / "agentwire"),
     "/usr/local/bin/agentwire",
 ])
-LOCK_FILE = Path("/tmp/agentwire-listen.lock")
-PID_FILE = Path("/tmp/agentwire-listen.pid")
-AUDIO_FILE = Path("/tmp/agentwire-listen.wav")
-DEBUG_LOG = Path("/tmp/agentwire-listen.log")
+# Runtime state lives under user-private dirs (0700), never world-writable /tmp:
+# fixed /tmp names are pre-plantable by co-tenants (CWE-377).
+RUN_DIR = Path.home() / ".agentwire" / "run"
+LOG_DIR = Path.home() / ".agentwire" / "logs"
+LOCK_FILE = RUN_DIR / "listen.lock"
+PID_FILE = RUN_DIR / "listen.pid"
+AUDIO_PATH_FILE = RUN_DIR / "listen.audio-path"
+DEBUG_LOG = LOG_DIR / "listen.log"
+
+
+def _ensure_private_dir(path: Path) -> None:
+    path.mkdir(mode=0o700, parents=True, exist_ok=True)
 
 
 def log(msg: str) -> None:
-    """Log debug message."""
-    with open(DEBUG_LOG, "a") as f:
+    """Log debug message (O_NOFOLLOW so a planted symlink can't redirect writes)."""
+    _ensure_private_dir(LOG_DIR)
+    fd = os.open(DEBUG_LOG, os.O_WRONLY | os.O_CREAT | os.O_APPEND | os.O_NOFOLLOW, 0o600)
+    with os.fdopen(fd, "a") as f:
         f.write(f"{time.strftime('%Y-%m-%d %H:%M:%S')}: {msg}\n")
 
 
+def _new_audio_file() -> Path:
+    """Create an unpredictable 0600 audio temp file and record its path."""
+    _ensure_private_dir(RUN_DIR)
+    fd, path = tempfile.mkstemp(prefix="agentwire-listen-", suffix=".wav", dir=RUN_DIR)
+    os.close(fd)
+    AUDIO_PATH_FILE.write_text(path)
+    return Path(path)
+
+
+def _current_audio_file() -> Path | None:
+    """Path of the in-flight recording, if any (spans start/stop invocations)."""
+    try:
+        text = AUDIO_PATH_FILE.read_text().strip()
+    except OSError:
+        return None
+    return Path(text) if text else None
+
+
+def _cleanup_audio_file() -> None:
+    audio = _current_audio_file()
+    if audio is not None:
+        audio.unlink(missing_ok=True)
+    AUDIO_PATH_FILE.unlink(missing_ok=True)
+
+
 def notify(msg: str) -> None:
     """Show system notification (non-blocking)."""
     if sys.platform == "darwin":
@@ -162,14 +198,18 @@ def start_recording() -> int:
     log("start_recording called")
 
     # Clean up any stale recording
-    subprocess.run(["pkill", "-9", "-f", "ffmpeg.*agentwire-listen\\.wav"],
+    subprocess.run(["pkill", "-9", "-f", "ffmpeg.*agentwire-listen-"],
                    capture_output=True)
+    _ensure_private_dir(RUN_DIR)
     LOCK_FILE.unlink(missing_ok=True)
     PID_FILE.unlink(missing_ok=True)
-    AUDIO_FILE.unlink(missing_ok=True)
+    _cleanup_audio_file()
     time.sleep(0.1)
 
-    LOCK_FILE.touch()
+    # Exclusive create: a pre-planted lock file is an error, not silently reused
+    lock_fd = os.open(LOCK_FILE, os.O_WRONLY | os.O_CREAT | os.O_EXCL, 0o600)
+    os.close(lock_fd)
+    audio_file = _new_audio_file()
     beep("start")
 
     # Record audio (16kHz mono for whisper)
@@ -186,7 +226,7 @@ def start_recording() -> int:
             [FFMPEG_PATH, "-f", "avfoundation", "-i", input_spec,
              "-ar", "16000", "-ac", "1",
              "-acodec", "pcm_s16le",  # Uncompressed for quality
-             str(AUDIO_FILE), "-y"],
+             str(audio_file), "-y"],
             stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL,
         )
     else:
@@ -195,7 +235,7 @@ def start_recording() -> int:
             ["ffmpeg", "-f", "pulse", "-i", "default",
              "-ar", "16000", "-ac", "1",
              "-acodec", "pcm_s16le",
-             str(AUDIO_FILE), "-y"],
+             str(audio_file), "-y"],
             stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL,
         )
 
@@ -239,7 +279,7 @@ def stop_recording(session: str, voice_prompt: bool = True, type_at_cursor: bool
         PID_FILE.unlink(missing_ok=True)
 
     # Force kill any remaining ffmpeg processes
-    subprocess.run(["pkill", "-9", "-f", "ffmpeg.*agentwire-listen\\.wav"],
+    subprocess.run(["pkill", "-9", "-f", "ffmpeg.*agentwire-listen-"],
                    capture_output=True)
     LOCK_FILE.unlink(missing_ok=True)
 
@@ -247,7 +287,8 @@ def stop_recording(session: str, voice_prompt: bool = True, type_at_cursor: bool
     time.sleep(0.3)
 
     # Verify file exists and has content
-    if not AUDIO_FILE.exists():
+    audio_file = _current_audio_file()
+    if audio_file is None or not audio_file.exists():
         log("ERROR: No audio file")
         notify("Recording failed")
         beep("error")
@@ -256,14 +297,14 @@ def stop_recording(session: str, voice_prompt: bool = True, type_at_cursor: bool
     # Wait for file to stabilize (size stops changing)
     last_size = 0
     for _ in range(10):  # Max 1 second wait
-        current_size = AUDIO_FILE.stat().st_size
+        current_size = audio_file.stat().st_size
         if current_size > 0 and current_size == last_size:
             break
         last_size = current_size
         time.sleep(0.1)
 
-    if AUDIO_FILE.stat().st_size < 1000:  # Less than 1KB is likely corrupt
-        log(f"ERROR: Audio file too small ({AUDIO_FILE.stat().st_size} bytes)")
+    if audio_file.stat().st_size < 1000:  # Less than 1KB is likely corrupt
+        log(f"ERROR: Audio file too small ({audio_file.stat().st_size} bytes)")
         notify("Recording too short")
         beep("error")
         return 1
@@ -285,7 +326,7 @@ def stop_recording(session: str, voice_prompt: bool = True, type_at_cursor: bool
         return 1
     stt_url = stt_config.get("url", "http://localhost:8101")
 
-    text = transcribe_via_server(AUDIO_FILE, stt_url)
+    text = transcribe_via_server(audio_file, stt_url)
     if text:
         log(f"Used STT shim at {stt_url}")
     else:
@@ -298,7 +339,7 @@ def stop_recording(session: str, voice_prompt: bool = True, type_at_cursor: bool
         log("ERROR: No speech detected")
         notify("No speech detected")
         beep("error")
-        AUDIO_FILE.unlink(missing_ok=True)
+        _cleanup_audio_file()
         return 1
 
     log(f"Transcribed: {text}")
@@ -310,7 +351,7 @@ def stop_recording(session: str, voice_prompt: bool = True, type_at_cursor: bool
         beep("done")
         notify(f"Transcribed: {text[:30]}...")
         print(text)
-        AUDIO_FILE.unlink(missing_ok=True)
+        _cleanup_audio_file()
         return 0
 
     if type_at_cursor:
@@ -345,7 +386,7 @@ def stop_recording(session: str, voice_prompt: bool = True, type_at_cursor: bool
             log(f"ERROR: Hammerspoon failed: {result.stderr}")
             notify("Failed to type text")
             beep("error")
-            AUDIO_FILE.unlink(missing_ok=True)
+            _cleanup_audio_file()
             return 1
 
         beep("done")
@@ -366,7 +407,7 @@ def stop_recording(session: str, voice_prompt: bool = True, type_at_cursor: bool
             beep("error")
             print(f"Transcribed: {text}")
             print(f"But session '{session}' not running. Start with: agentwire dev")
-            AUDIO_FILE.unlink(missing_ok=True)
+            _cleanup_audio_file()
             return 1
 
         # Build message
@@ -388,14 +429,14 @@ def stop_recording(session: str, voice_prompt: bool = True, type_at_cursor: bool
             log(f"ERROR: agentwire send raised exception: {e}")
             notify("Failed to send to session")
             beep("error")
-            AUDIO_FILE.unlink(missing_ok=True)
+            _cleanup_audio_file()
             return 1
 
         if result.returncode != 0:
             log(f"ERROR: agentwire send failed: {result.stderr}")
             notify("Failed to send to session")
             beep("error")
-            AUDIO_FILE.unlink(missing_ok=True)
+            _cleanup_audio_file()
             return 1
 
         beep("done")
@@ -403,7 +444,7 @@ def stop_recording(session: str, voice_prompt: bool = True, type_at_cursor: bool
         notify(f"Sent: {text[:30]}...")
         print(f"Sent to {session}: {text}")
 
-    AUDIO_FILE.unlink(missing_ok=True)
+    _cleanup_audio_file()
     return 0
 
 
@@ -417,10 +458,10 @@ def cancel_recording() -> int:
             pass
         PID_FILE.unlink(missing_ok=True)
 
-    subprocess.run(["pkill", "-9", "-f", "ffmpeg.*agentwire-listen\\.wav"],
+    subprocess.run(["pkill", "-9", "-f", "ffmpeg.*agentwire-listen-"],
                    capture_output=True)
     LOCK_FILE.unlink(missing_ok=True)
-    AUDIO_FILE.unlink(missing_ok=True)
+    _cleanup_audio_file()
 
     beep("error")
     notify("Cancelled")

{agentwire_dev-1.51.0 → agentwire_dev-1.52.0}/agentwire/routes/voice.py

@@ -19,6 +19,8 @@ from pathlib import Path
 
 from aiohttp import web
 
+from ..security import read_multipart_field_limited
+
 logger = logging.getLogger(__name__)
 
 
@@ -119,7 +121,16 @@ class VoiceRoutesMixin:
             if audio_field is None:
                 return web.json_response({"error": "No audio data"})
 
-            audio_data = await audio_field.read()
+            # Stream with a size cap: abort 413 before buffering an over-limit
+            # body into RAM. Dedicated stt.max_upload_mb wins if configured,
+            # else reuse the general uploads cap.
+            max_mb = (
+                getattr(self.config.stt, "max_upload_mb", None)
+                or self.config.uploads.max_size_mb
+            )
+            audio_data = await read_multipart_field_limited(
+                audio_field, max_mb * 1024 * 1024
+            )
             if not audio_data:
                 return web.json_response({"error": "Empty audio data"})
 
@@ -148,6 +159,8 @@ class VoiceRoutesMixin:
             finally:
                 Path(wav_path).unlink(missing_ok=True)
 
+        except web.HTTPException:
+            raise
         except Exception as e:
             logger.error(f"Transcription failed: {e}")
             return web.json_response({"error": str(e)})

{agentwire_dev-1.51.0 → agentwire_dev-1.52.0}/agentwire/security.py

@@ -23,11 +23,15 @@ Two layers, both enforced by a single aiohttp middleware:
 disable auth (loopback binds only); any other string → explicit override.
 """
 
+import base64
+import hashlib
 import hmac
 import ipaddress
 import logging
+import os
 import re
 import secrets
+import tempfile
 import time
 from pathlib import Path
 from typing import Callable, Optional
@@ -80,10 +84,29 @@ def read_token_file() -> Optional[str]:
 
 
 def write_token_file(token: str) -> None:
-    """Write the token file with owner-only permissions."""
-    TOKEN_FILE.parent.mkdir(parents=True, exist_ok=True)
-    TOKEN_FILE.write_text(token + "\n")
-    TOKEN_FILE.chmod(0o600)
+    """Write the token file with owner-only permissions.
+
+    Atomic and never wider than 0600: the token is written to a same-directory
+    temp file created at 0600 (fchmod before any bytes land), then renamed over
+    the destination — there is no window where the god-token is group/world
+    readable, even on first creation under a permissive umask. The config dir
+    itself is created 0700 when missing. Rotation over an existing 0600 file
+    keeps 0600 (os.replace swaps the inode; the new one is already 0600).
+    """
+    parent = TOKEN_FILE.parent
+    parent.mkdir(parents=True, exist_ok=True, mode=0o700)
+    fd, tmp_path = tempfile.mkstemp(dir=parent, prefix=".portal.token.")
+    try:
+        os.fchmod(fd, 0o600)
+        with os.fdopen(fd, "w") as f:
+            f.write(token + "\n")
+        os.replace(tmp_path, TOKEN_FILE)
+    except BaseException:
+        try:
+            os.unlink(tmp_path)
+        except OSError:
+            pass
+        raise
 
 
 def resolve_auth_token(config) -> Optional[str]:
@@ -347,6 +370,144 @@ def resolve_device(provided: Optional[str], auth_token: Optional[str]) -> Option
     return devices_mod.load_registry_cached().resolve(provided)
 
 
+# ---------------------------------------------------------------------------
+# Security response headers (CSP & friends)
+
+_TEMPLATES_DIR = Path(__file__).parent / "templates"
+_INLINE_SCRIPT_RE = re.compile(r"<script\b[^>]*>(.*?)</script>", re.DOTALL | re.IGNORECASE)
+
+
+def _inline_script_hashes() -> list[str]:
+    """CSP sha256 sources for inline <script> blocks in the bundled templates.
+
+    The pair page ships a small inline module (no Jinja interpolation inside
+    it), so ``script-src 'self'`` alone would break pairing. Hashing the blocks
+    at startup keeps script-src locked down while auto-healing when a template's
+    inline script changes.
+    """
+    hashes: list[str] = []
+    try:
+        for tpl in sorted(_TEMPLATES_DIR.glob("*.html")):
+            for m in _INLINE_SCRIPT_RE.finditer(tpl.read_text()):
+                body = m.group(1)
+                if not body.strip():
+                    continue
+                digest = base64.b64encode(hashlib.sha256(body.encode()).digest()).decode()
+                hashes.append(f"'sha256-{digest}'")
+    except OSError:
+        pass
+    return hashes
+
+
+def _build_csp() -> str:
+    """Portal-wide Content-Security-Policy.
+
+    Constraints baked in from the real UI:
+    - xterm.js / marked load from cdn.jsdelivr.net (script + css).
+    - Inline <style> attributes are used throughout (and WinBox injects a
+      style element) → style-src needs 'unsafe-inline'.
+    - WinBox uses data: SVG background images; uploads render as blobs.
+    - The dashboard/session/terminal WebSockets need ws:/wss:, and the
+      announcement modal fetches raw.githubusercontent.com.
+    - Voice playback uses blob: audio; browser STT records via MediaRecorder.
+    """
+    script_src = " ".join(["'self'", "https://cdn.jsdelivr.net"] + _inline_script_hashes())
+    return "; ".join([
+        "default-src 'self'",
+        f"script-src {script_src}",
+        # fonts.googleapis.com: the Council window injects a Google Fonts
+        # stylesheet (council-window.js); fonts.gstatic.com serves the woff2s.
+        "style-src 'self' 'unsafe-inline' https://cdn.jsdelivr.net https://fonts.googleapis.com",
+        "img-src 'self' data: blob:",
+        "font-src 'self' data: https://fonts.gstatic.com",
+        "connect-src 'self' ws: wss: https://raw.githubusercontent.com",
+        "media-src 'self' blob: data:",
+        "worker-src 'self' blob:",
+        "frame-src 'self'",
+        "object-src 'none'",
+        "base-uri 'self'",
+        "frame-ancestors 'self'",
+    ])
+
+
+# Artifacts are agent-generated HTML rendered in sandboxed iframes; they may
+# legitimately carry inline scripts/styles and pull CDN libraries, so the
+# policy stays permissive on content while locking embedding (frame-ancestors)
+# and plugins. The iframe sandbox attribute remains the primary containment.
+_ARTIFACTS_CSP = "; ".join([
+    "default-src 'self' 'unsafe-inline' data: blob: https:",
+    "object-src 'none'",
+    "base-uri 'self'",
+    "frame-ancestors 'self'",
+])
+
+
+def create_security_headers_middleware(hsts_enabled: bool = False):
+    """Middleware stamping security response headers on every response.
+
+    HSTS is opt-in (``server.hsts``) and emitted only on TLS requests: agentwire
+    commonly serves HTTPS with a self-signed cert, and a pinned HSTS policy
+    removes the cert-error click-through — a rotated/expired self-signed cert
+    would hard-lock the browser out of the portal.
+    """
+    csp = _build_csp()
+
+    @web.middleware
+    async def security_headers_middleware(request: web.Request, handler):
+        try:
+            response = await handler(request)
+        except web.HTTPException as exc:
+            _stamp_security_headers(request, exc, csp, hsts_enabled)
+            raise
+        _stamp_security_headers(request, response, csp, hsts_enabled)
+        return response
+
+    return security_headers_middleware
+
+
+def _stamp_security_headers(
+    request: web.Request, response, csp: str, hsts_enabled: bool
+) -> None:
+    headers = response.headers
+    headers.setdefault("X-Content-Type-Options", "nosniff")
+    headers.setdefault("X-Frame-Options", "SAMEORIGIN")
+    headers.setdefault("Referrer-Policy", "same-origin")
+    if request.path.startswith("/artifacts/"):
+        headers["Content-Security-Policy"] = _ARTIFACTS_CSP
+    else:
+        headers.setdefault("Content-Security-Policy", csp)
+    if hsts_enabled and request.secure:
+        headers.setdefault("Strict-Transport-Security", "max-age=31536000")
+
+
+# ---------------------------------------------------------------------------
+# Bounded multipart reads (upload DoS guard)
+
+
+async def read_multipart_field_limited(field, max_bytes: int) -> bytes:
+    """Read a multipart field, aborting with 413 once ``max_bytes`` is exceeded.
+
+    ``await field.read()`` buffers the entire part into RAM before any size
+    check can run (aiohttp's ``client_max_size`` does not bound the streaming
+    ``request.multipart()`` path) — an oversized upload would balloon the
+    portal's memory before being rejected. Streaming chunk-by-chunk caps the
+    buffered amount at ``max_bytes`` + one chunk.
+    """
+    chunks: list[bytes] = []
+    size = 0
+    while True:
+        chunk = await field.read_chunk()
+        if not chunk:
+            break
+        size += len(chunk)
+        if size > max_bytes:
+            raise web.HTTPRequestEntityTooLarge(
+                max_size=max_bytes, actual_size=size,
+            )
+        chunks.append(chunk)
+    return b"".join(chunks)
+
+
 # ---------------------------------------------------------------------------
 # Auth-failure tracking + lockout (gap #5)
 

{agentwire_dev-1.51.0 → agentwire_dev-1.52.0}/agentwire/send_cli.py

@@ -116,11 +116,11 @@ def cmd_send(args) -> int:
 
         if use_buffer:
             encoded = base64.b64encode(prompt.encode()).decode()
+            # Pipe straight into the tmux buffer — no on-disk temp that could
+            # expose message content or be pre-planted on the remote host
             cmd = (
-                f"echo {shlex.quote(encoded)} | base64 -d > /tmp/aw-send-$$.txt && "
-                f"tmux load-buffer /tmp/aw-send-$$.txt && "
+                f"echo {shlex.quote(encoded)} | base64 -d | tmux load-buffer - && "
                 f"tmux paste-buffer -t {quoted_session} && "
-                f"rm -f /tmp/aw-send-$$.txt && "
                 f"sleep 0.5 && "
                 f"tmux send-keys -t {quoted_session} Enter"
             )