qbraid-cli 0.16.9__tar.gz → 0.16.10__tar.gz

{qbraid_cli-0.16.9/qbraid_cli.egg-info → qbraid_cli-0.16.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qbraid-cli
-Version: 0.16.9
+Version: 0.16.10
 Summary: Command Line Interface for interacting with all parts of the qBraid platform.
 Author-email: qBraid Development Team <contact@qbraid.com>
 License-Expression: LicenseRef-Proprietary
@@ -30,11 +30,11 @@ Requires-Dist: typer>=0.12.1
 Requires-Dist: rich>=10.11.0
 Requires-Dist: click<=8.5.0
 Requires-Dist: questionary>=2.0.0
-Requires-Dist: qbraid-core>=0.6.21
+Requires-Dist: qbraid-core>=0.6.27
 Provides-Extra: compute
-Requires-Dist: qbraid-core[compute]>=0.6.21; extra == "compute"
+Requires-Dist: qbraid-core[compute]>=0.6.27; extra == "compute"
 Provides-Extra: envs
-Requires-Dist: qbraid-core[environments]>=0.6.21; extra == "envs"
+Requires-Dist: qbraid-core[environments]>=0.6.27; extra == "envs"
 Provides-Extra: dev
 Requires-Dist: isort; extra == "dev"
 Requires-Dist: black; extra == "dev"

{qbraid_cli-0.16.9 → qbraid_cli-0.16.10}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "qbraid-cli"
-version = "0.16.9"
+version = "0.16.10"
 description = "Command Line Interface for interacting with all parts of the qBraid platform."
 readme = "README.md"
 authors = [{ name = "qBraid Development Team", email = "contact@qbraid.com" }]
@@ -32,7 +32,7 @@ dependencies = [
     "rich>=10.11.0",
     "click<=8.5.0",
     "questionary>=2.0.0",
-    "qbraid-core>=0.6.21",
+    "qbraid-core>=0.6.27",
 ]
 requires-python = ">= 3.10"
 
@@ -43,8 +43,8 @@ Documentation = "https://docs.qbraid.com/v2/cli/api-reference/qbraid"
 Discord = "https://discord.gg/KugF6Cnncm"
 
 [project.optional-dependencies]
-compute = ["qbraid-core[compute]>=0.6.21"]
-envs = ["qbraid-core[environments]>=0.6.21"]
+compute = ["qbraid-core[compute]>=0.6.27"]
+envs = ["qbraid-core[environments]>=0.6.27"]
 dev = ["isort", "black", "pytest", "pytest-cov", "pytest-asyncio"]
 
 [project.scripts]

{qbraid_cli-0.16.9 → qbraid_cli-0.16.10}/qbraid_cli/agents/app.py

@@ -134,6 +134,7 @@ def _status_style(status_value: str) -> str:
         "idle": "dim",
         "error": "red",
         "stopped": "red",
+        "interrupted": "yellow",
     }
     return styles.get(status_value, "dim")
 
@@ -259,6 +260,38 @@ def _is_registry_error(err: Exception) -> bool:
     return isinstance(err, AgentRegistryError)
 
 
+def _lifecycle_view(registry, session):
+    """The record as Core lists it (qbraid-core #419's read-time overlay).
+
+    Another Lab's live-or-unknown native row is stored as it was and listed
+    as interrupted (``status_overlay``). Displays and decisions that must
+    agree with the list classify through ``session_lifecycle_view``; an older
+    Core, or a view that fails on this row, gives the stored record.
+    """
+    view = _core_method(registry, "session_lifecycle_view")
+    if view is None:
+        return session
+    try:
+        return view(session)
+    except Exception:  # pylint: disable=broad-exception-caught
+        return session
+
+
+def _interrupted(session) -> bool:
+    """Stopped because its runtime vanished (or shown so), with nothing after."""
+    status = getattr(getattr(session, "status", None), "value", getattr(session, "status", None))
+    at = (session.metadata or {}).get("interrupted_at")
+    if status != "stopped" or isinstance(at, bool) or not isinstance(at, (int, float)):
+        return False
+    return (session.last_activity or at) <= at
+
+
+def _status_label(session) -> str:
+    if _interrupted(session):
+        return "interrupted"
+    return session.status.value if session.status else "idle"
+
+
 def _session_status(registry, session_id: str) -> Optional[str]:
     """The registry status of a session ("stopped", "working", ...), or None
     when it is not registered or the registry cannot be read."""
@@ -340,6 +373,174 @@ def agents_register():
         raise typer.Exit(code=0)
 
 
+def _own_pid_namespace():
+    """This process's PID namespace (``pid:[<inode>]``), or None without /proc."""
+    try:
+        return os.readlink("/proc/self/ns/pid")
+    except (OSError, AttributeError):
+        return None
+
+
+def _foreign_pid_reason(session):
+    """Why this session's recorded PID must not be signalled from here, or None.
+
+    A PID number names a process only in the namespace that issued it: a
+    session recorded in another PID namespace (another Lab, container or
+    machine) could name an unrelated process of ours.
+    """
+    if (
+        getattr(session, "compute_id", None)
+        or getattr(session, "machine_id", None)
+        or getattr(session, "cluster_id", None)
+    ):
+        return "it belongs to another machine."
+    metadata = getattr(session, "metadata", None) or {}
+    namespace = metadata.get("jupyter_process_pid_ns")
+    # Missing, null and malformed are one case: the namespace is unknown.
+    known = isinstance(namespace, str) and _PID_NAMESPACE.fullmatch(namespace) is not None
+    if not known and (metadata.get("jupyter_server_id") or namespace is not None):
+        return "it was recorded by a Lab server whose PID namespace is unknown."
+    if known:
+        own = _own_pid_namespace()
+        if own is None or namespace != own:
+            return "it was recorded in another PID namespace, where that number may be a different process."
+    # The agent's own scope, recorded on tmux and hook rows (qbraid-core #419).
+    if "agent_pid_ns" in metadata:
+        agent_ns = metadata.get("agent_pid_ns")
+        own = _own_pid_namespace()
+        if (
+            not (isinstance(agent_ns, str) and _PID_NAMESPACE.fullmatch(agent_ns))
+            or own is None
+            or agent_ns != own
+        ):
+            return (
+                "its agent was recorded in another PID namespace, "
+                "where that number may be a different process."
+            )
+    if "agent_boot_id" in metadata:
+        boot = metadata.get("agent_boot_id")
+        own_boot = _own_boot_id()
+        if not isinstance(boot, str) or not boot or own_boot is None or boot != own_boot:
+            return "its agent was recorded under another boot, where that number may be a different process."
+    return None
+
+
+def _own_boot_id():
+    """This kernel's boot id, or None without /proc."""
+    try:
+        with open("/proc/sys/kernel/random/boot_id", encoding="ascii") as handle:
+            return handle.read().strip() or None
+    except OSError:
+        return None
+
+
+_PID_NAMESPACE = re.compile(r"pid:\[\d+\]")
+
+
+def _not_running_reason(session):
+    """Why a row no longer names a running agent, or None."""
+    status = getattr(getattr(session, "status", None), "value", getattr(session, "status", None))
+    if status in ("stopped", "error"):
+        return "the session is not running, so its PID and window name may now be someone else's."
+    return None
+
+
+def _signal_agent(pid, force):
+    sig = signal.SIGKILL if force else signal.SIGTERM
+    sig_name = "SIGKILL" if force else "SIGTERM"
+    try:
+        os.kill(pid, sig)
+        console.print(f"[green]Sent {sig_name} to process {pid}.[/green]")
+    except (OSError, ProcessLookupError):
+        console.print(f"[dim]Process {pid} already stopped.[/dim]")
+
+
+def _kill_tmux_session(session):
+    """Stop a tmux-hosted agent only through a verified target.
+
+    A saved window name is mutable: another session may hold it now. Core's
+    kill_bound closes the window by the runtime's immutable window id and
+    records the stop only once the agent exited. Anything unverified exits
+    non-zero and leaves the registry alone.
+    """
+    from qbraid_core.services.agents import AgentLauncher, AgentLauncherError
+
+    launcher = AgentLauncher()
+    if not callable(getattr(launcher, "kill_bound", None)):
+        # Core has had kill_bound since 0.6.5; a saved window name alone is
+        # never trusted, so without it nothing is closed.
+        console.print(
+            "[red]Not stopped:[/red] this qbraid-core cannot verify a tmux window; update qbraid-core.",
+            highlight=False,
+        )
+        raise typer.Exit(code=1)
+    try:
+        launcher.kill_bound(session.session_id)
+    except AgentLauncherError as error:
+        console.print(
+            "[red]Not stopped: Core could not verify this session's tmux window.[/red] "
+            f"{escape(str(error))}",
+            highlight=False,
+        )
+        raise typer.Exit(code=1) from error
+    console.print(f"[green]Stopped the agent in tmux window '{escape(session.tmux_window)}'.[/green]")
+
+
+_GONE = "gone"
+# create_time() and started_at come from different clocks reads; allow this much.
+_START_SLACK_S = 5.0
+
+
+def _agent_identity_refusal(session):
+    """Why the recorded PID must not be signalled as this session's agent, or None.
+
+    A registry outlives its processes (it is in $HOME across pod restarts),
+    so a PID number alone may now name an unrelated process. It is signalled
+    only when psutil shows this tool's agent, started no later than the
+    session. Anything that cannot be checked is refused. Returns ``_GONE``
+    when no process has that PID.
+    """
+    status = getattr(getattr(session, "status", None), "value", getattr(session, "status", None))
+    if status in ("stopped", "error"):
+        return "the session is not running, so that number may now be another process."
+    try:
+        import psutil  # pylint: disable=import-outside-toplevel
+        from qbraid_core.services.agents.registry import (  # pylint: disable=import-outside-toplevel
+            process_runs_agent,
+        )
+    except ImportError:
+        return "this qbraid-core cannot check the process's identity; update it."
+    started = getattr(session, "started_at", None)
+    tool = getattr(getattr(session, "tool", None), "value", None)
+    try:
+        process = psutil.Process(session.pid)
+        # This tool's agent, and already running when the session started.
+        if (
+            not tool
+            or not isinstance(started, (int, float))
+            or not process_runs_agent(process, tool)
+            or process.create_time() > started + _START_SLACK_S
+        ):
+            return "it is not this session's agent."
+    except psutil.NoSuchProcess:
+        return _GONE
+    except (psutil.AccessDenied, psutil.Error):
+        return "its identity could not be checked (access denied)."
+    return None
+
+
+def _end_reported_kwargs(method) -> dict:
+    """`agent_end_reported=True` when this Core's deregister takes it."""
+    try:
+        return (
+            {"agent_end_reported": True}
+            if "agent_end_reported" in inspect.signature(method).parameters
+            else {}
+        )
+    except (TypeError, ValueError):
+        return {}
+
+
 @agents_app.command("deregister", hidden=True)
 def agents_deregister():
     """Deregister an agent session.
@@ -358,6 +559,9 @@ def agents_deregister():
         from qbraid_core.services.agents import AgentSessionRegistryManager
 
         registry = AgentSessionRegistryManager()
+        # This is the agent's own end hook: say so, where Core can record it
+        # (it lets a cleared PID read as exited). Nothing else may claim it.
+        ended = _end_reported_kwargs(registry.deregister_session)
 
         session_id = data.get("session_id", data.get("id"))
         pid = data.get("pid")
@@ -365,15 +569,19 @@ def agents_deregister():
         # Try to find and deregister by session_id, then by pid
         if session_id:
             try:
-                registry.deregister_session(session_id=session_id)
-                raise typer.Exit(code=0)
-            except Exception:
-                pass
+                ended_id = registry.deregister_session(session_id=session_id, **ended)
+            except Exception:  # pylint: disable=broad-exception-caught
+                ended_id = None  # unreadable by id: try the PID below
+            if ended_id is not None:
+                return  # ended by id; the PID path is only for an unknown id
 
         if pid:
+            # The hook's PID is in this process's scope: a row recorded in
+            # another namespace, boot or machine that holds the same number
+            # is someone else's agent, never this one's end.
             session = registry.find_by_pid(int(pid))
-            if session:
-                registry.deregister_session(session_id=session.session_id)
+            if session and not _foreign_pid_reason(session):
+                registry.deregister_session(session_id=session.session_id, **ended)
 
     except (typer.Exit, SystemExit):
         raise
@@ -578,7 +786,7 @@ def agents_list(
                 if not name_val and s.cwd:
                     name_val = Path(s.cwd).name
                 tool_val = s.tool.value if s.tool else "-"
-                status_val = s.status.value if s.status else "idle"
+                status_val = _status_label(s)
                 style = _status_style(status_val)
 
                 # Add time-ago to status
@@ -772,9 +980,9 @@ def agents_status(
             console.print("[dim]Use 'qbraid agents list' to see active sessions.[/dim]")
             raise typer.Exit(code=1)
 
-        # Build detail lines
-        s = match
-        status_val = s.status.value if s.status else "idle"
+        # Build detail lines, as the list shows the record
+        s = _lifecycle_view(registry, match)
+        status_val = _status_label(s)
         style = _status_style(status_val)
 
         lines = []
@@ -1121,39 +1329,75 @@ def agents_kill(
         session = matches[0]
         pid = session.pid
 
+        # Shown as interrupted (another Lab's row this Lab cannot verify):
+        # refused before anything, Core included, so nothing is written for
+        # it. Other native rows go to Core, which asks their owning server.
+        if (_lifecycle_view(registry, session).metadata or {}).get("status_overlay"):
+            console.print(
+                "[red]Not stopped:[/red] it belongs to another Lab that this Lab cannot verify, so it is "
+                "listed as interrupted. Resume it with --confirm-owner-gone, or stop it from its own Lab. "
+                "Nothing was signalled or closed.",
+                highlight=False,
+            )
+            raise typer.Exit(code=1)
+
         if session.metadata.get("terminal_backend") == "jupyter":
-            from qbraid_core.services.agents import AgentLauncher
+            # A native agent belongs to its Lab server, which Core reaches and
+            # verifies; its PID may be another namespace's. Never signalled here.
+            from qbraid_core.services.agents import AgentLauncher, AgentLauncherError
+            from qbraid_core.services.agents.exceptions import AgentRuntimeUnavailableError
 
-            AgentLauncher().kill_bound(session.session_id)
+            try:
+                AgentLauncher().kill_bound(session.session_id)
+            except AgentRuntimeUnavailableError as error:
+                if _not_running_reason(session):
+                    # Nothing to verify: Core says why (e.g. no longer active).
+                    console.print(f"[red]Not stopped:[/red] {escape(str(error))}", highlight=False)
+                else:
+                    console.print(
+                        "[red]Could not verify the Lab server that owns this agent; "
+                        "nothing was stopped.[/red] "
+                        f"{escape(str(error))}",
+                        highlight=False,
+                    )
+                raise typer.Exit(code=1)
+            except AgentLauncherError as error:
+                console.print(f"[red]Not stopped:[/red] {escape(str(error))}", highlight=False)
+                raise typer.Exit(code=1)
             console.print("[green]Stopped native Lab agent.[/green]")
             return
 
-        # For tmux-managed sessions, kill the tmux window
-        if session.tmux_session and session.tmux_window:
-            try:
-                import subprocess
+        # Refused before anything is touched: a row of another PID namespace or
+        # machine, or one no longer running, names a PID and a tmux window that
+        # may now belong to someone else.
+        refusal = _foreign_pid_reason(session) or _not_running_reason(session)
+        if refusal:
+            console.print(
+                f"[red]Not stopped:[/red] {escape(refusal)} Nothing was signalled or closed.", highlight=False
+            )
+            raise typer.Exit(code=1)
 
-                subprocess.run(
-                    ["tmux", "kill-window", "-t", f"{session.tmux_session}:{session.tmux_window}"],
-                    capture_output=True,
-                    check=False,
-                )
-                console.print(f"[green]Killed tmux window '{session.tmux_window}'.[/green]")
-            except Exception:
-                pass
+        if session.tmux_session and session.tmux_window:
+            _kill_tmux_session(session)
+            return
 
-        # Send signal to the process if we have a valid PID
-        if pid and pid > 0:
-            sig = signal.SIGKILL if force else signal.SIGTERM
-            sig_name = "SIGKILL" if force else "SIGTERM"
-            try:
-                os.kill(pid, 0)  # check alive
-                os.kill(pid, sig)
-                console.print(f"[green]Sent {sig_name} to process {pid}.[/green]")
-            except (OSError, ProcessLookupError):
-                console.print(f"[dim]Process {pid} already stopped.[/dim]")
+        if not (pid and pid > 0):
+            console.print(
+                "[red]Not stopped:[/red] no agent process or terminal is recorded for this session."
+            )
+            raise typer.Exit(code=1)
+        identity = _agent_identity_refusal(session)
+        if identity == _GONE:
+            console.print(f"[dim]Process {pid} already stopped.[/dim]")
+        elif identity:
+            console.print(
+                f"[red]Not stopped. Did not signal PID {pid}:[/red] {escape(identity)}", highlight=False
+            )
+            raise typer.Exit(code=1)
+        else:
+            _signal_agent(pid, force)
 
-        # Mark stopped in registry
+        # Verified gone or signalled: mark stopped in registry
         registry.deregister_session(session_id=session.session_id)
         console.print(
             f"[dim]Session {session.session_id[:8]} "
@@ -1623,6 +1867,139 @@ def _hook_trust_kwargs(method, value):
     return {"trust_hooks": value}
 
 
+OWNER_GONE_PAUSED = "The old Lab may be paused; only confirm if you closed or restarted it."
+OWNER_GONE_WARNING = (
+    "The old Lab may be paused; only confirm if you closed or restarted it. "
+    "Confirming while it still runs starts a second copy of the agent."
+)
+
+
+def _owner_confirmation_supported(launcher) -> bool:
+    """Whether this Core can take a confirmation that a session's old Lab is gone."""
+    try:
+        return all(
+            "confirm_owner_gone" in inspect.signature(method).parameters
+            for method in (launcher.resume, launcher.resume_preflight)
+        )
+    except (AttributeError, TypeError, ValueError):
+        return False
+
+
+def _exact_session_id(target: str) -> str:
+    """One session's full id for a full id, unique prefix or name."""
+    from qbraid_core.services.agents import AgentLauncherError
+
+    sessions = _get_registry().search_sessions(include_stopped=True)
+    exact = [s for s in sessions if s.session_id == target]
+    if exact:
+        return exact[0].session_id
+    matches = [
+        s
+        for s in sessions
+        if s.session_id.startswith(target)
+        or (s.tmux_window and s.tmux_window == target)
+        or (s.terminal_name and s.terminal_name == target)
+    ]
+    if len(matches) != 1:
+        raise AgentLauncherError(
+            f"No session matches '{target}'."
+            if not matches
+            else f"Multiple sessions match '{target}'; give the full session ID."
+        )
+    return matches[0].session_id
+
+
+def _can_ask() -> bool:
+    """Whether a person is at a terminal to answer a prompt."""
+    import sys
+
+    return sys.stdin.isatty()
+
+
+def _confirm_owner_gone(launcher, session_id: str, yes: bool):
+    """Gate `resume --confirm-owner-gone`: Core's preflight first, then the person.
+
+    Returns what the resume should carry as ``confirm_owner_gone``: exactly
+    the Labs the preflight disclosed (``confirmServers``), or True from a Core
+    that lists none (it covers the source's own Lab). Returns None when Core
+    says no confirmation is needed. Exits otherwise.
+    """
+    from qbraid_core.services.agents import AgentLauncherError
+
+    if not _owner_confirmation_supported(launcher):
+        raise AgentLauncherError(
+            "--confirm-owner-gone requires a newer qbraid-core (confirm_owner_gone) on this machine."
+        )
+    preflight = launcher.resume_preflight(session_id)
+    if preflight.get("canResume"):
+        console.print(
+            "[dim]This session can be resumed without confirming anything; resuming normally.[/dim]"
+        )
+        return None
+    reason = preflight.get("reason") or "This session cannot be resumed."
+    if preflight.get("confirmable") is not True:
+        console.print(f"[red]{escape(reason)}[/red]", highlight=False)
+        wait = preflight.get("confirmableInS")
+        if preflight.get("confirmable") is False and isinstance(wait, (int, float)) and wait > 0:
+            minutes = max(1, -(-int(wait) // 60))
+            console.print(
+                f"You can confirm the old Lab is gone in about {minutes} min ({int(wait)} s). "
+                "Run this again then."
+            )
+        elif "confirmable" not in preflight:
+            console.print("Confirming the old Lab gone does not apply to this session.")
+        raise typer.Exit(code=1)
+    console.print(f"[yellow]{escape(reason)}[/yellow]", highlight=False)
+    if preflight.get("confirmReason"):
+        console.print(preflight["confirmReason"], markup=False, highlight=False)
+    # Core's reason already says what confirming risks; only the rest is added.
+    servers = preflight.get("confirmServers")
+    servers = list(servers) if isinstance(servers, list) and servers else None
+    if servers and len(servers) > 1:
+        console.print(f"This confirms {len(servers)} Lab servers gone: {', '.join(servers)}", markup=False)
+    console.print(
+        f"[bold]{OWNER_GONE_PAUSED if preflight.get('confirmReason') else OWNER_GONE_WARNING}[/bold]",
+        highlight=False,
+    )
+    confirmation = servers or True
+    if yes:
+        return confirmation
+    if not _can_ask():
+        console.print(
+            "[red]No terminal to ask on.[/red] Pass --yes only after the person has "
+            "confirmed that the old Lab is closed or restarted."
+        )
+        raise typer.Exit(code=2)
+    if not typer.confirm("Resume this session anyway?", default=False):
+        console.print("Not resumed.")
+        raise typer.Exit(code=1)
+    return confirmation
+
+
+#: A new runtime registers at once; one that started this long before the
+#: resume call was already running.
+_ALREADY_RUNNING_SLACK_S = 2.0
+
+
+def _already_running(session, resume_started: float) -> bool:
+    """Whether Core returned a runtime that was running before this resume.
+
+    Core #419 says so itself (`AgentSession.resumed_existing`: True only when
+    resume returned the running resumption). Anything else (an older Core
+    without the property) falls back to the start time: a runtime that
+    started before this call was already running.
+    """
+    said = getattr(session, "resumed_existing", None)
+    if said is True or said is False:
+        return said
+    started = getattr(session, "started_at", None)
+    return (
+        isinstance(started, (int, float))
+        and not isinstance(started, bool)
+        and started < resume_started - _ALREADY_RUNNING_SLACK_S
+    )
+
+
 def _startup_pending(session):
     return session.tool.value in ("codex", "claude") and not getattr(session, "startup_confirmed_at", None)
 
@@ -1967,6 +2344,24 @@ def agents_resume(
             "Default: keep the answer given at launch."
         ),
     ),
+    confirm_owner_gone: bool = typer.Option(
+        False,
+        "--confirm-owner-gone",
+        help=(
+            "For a session from a restarted Lab that cannot be verified: confirm its old Lab is "
+            "closed or restarted, and resume anyway. Asks first; confirming while that Lab still "
+            "runs starts a second copy of the agent."
+        ),
+    ),
+    yes: bool = typer.Option(
+        False,
+        "--yes",
+        "-y",
+        help=(
+            "With --confirm-owner-gone: do not ask. Agents must not pass this unless the person "
+            "has confirmed the old Lab is gone."
+        ),
+    ),
     compute: Optional[str] = typer.Option(None, "--compute", "-c", help="SSH alias for remote compute"),
 ):
     """Resume a previous agent session.
@@ -1974,10 +2369,24 @@ def agents_resume(
     Resumes with the selected terminal backend. With ``--compute`` the session is resumed
     on that machine, and a session id is required -- the interactive picker
     reads the local registry and cannot see another host's sessions.
+
+    ``--confirm-owner-gone`` is for a session whose old Lab (in another PID
+    namespace, after a restart) cannot be verified gone. Core's preflight runs
+    first; when it allows a confirmation, its reason and the risk are shown and
+    the person is asked (default No). Without a terminal it refuses unless
+    ``--yes`` is given. An agent must never pass ``--yes`` on its own judgement:
+    only after the person has confirmed that the old Lab is closed or restarted.
     """
     try:
         from qbraid_core.services.agents import AgentLauncherError
 
+        if yes and not confirm_owner_gone:
+            raise AgentLauncherError("--yes applies only to --confirm-owner-gone.")
+        if confirm_owner_gone and compute:
+            raise AgentLauncherError(
+                "--confirm-owner-gone is not available with --compute; run it on that machine, "
+                "where the person can be asked."
+            )
         if compute and backend != TerminalBackend.AUTO:
             raise AgentLauncherError("Remote resumes select the backend on the destination; omit --backend.")
         if compute:
@@ -2014,11 +2423,24 @@ def agents_resume(
 
         launcher = _backend_launcher(backend)
 
+        confirmation = {}
+        if confirm_owner_gone:
+            session_id = _exact_session_id(session_id)
+            confirmed = _confirm_owner_gone(launcher, session_id, yes)
+            if confirmed is not None:
+                # Only an explicit yes (or --yes) reaches Core: the Labs it was shown.
+                confirmation = {"confirm_owner_gone": confirmed}
+
+        # A runtime Core returns that started before this call is one already
+        # running (Core hands back a live resumption instead of a second copy).
+        resume_started = time.time()
+
         # Try resume — handle active session and ambiguous matches
         try:
             session = launcher.resume(
                 session_id=session_id,
                 name=name,
+                **confirmation,
                 **(_approval_kwargs(launcher.resume, approval.value) if approval else {}),
                 **_hook_trust_kwargs(launcher.resume, True if trust_hooks else None),
                 **_prompt_answer_kwargs(launcher.resume, trust_folder),
@@ -2045,6 +2467,18 @@ def agents_resume(
                 )
 
                 if choice in ("a", "attach"):
+                    active = next(
+                        (s for s in _get_registry().load_registry().sessions if s.session_id == active_sid),
+                        None,
+                    )
+                    foreign = (
+                        _foreign_pid_reason(active)
+                        if active is not None
+                        else "the active session is not recorded."
+                    )
+                    if foreign:
+                        console.print(f"[red]Not attached:[/red] {escape(foreign)}", highlight=False)
+                        raise typer.Exit(code=1)
                     target = f"{tmux_sess}:{tmux_win}"
                     console.print(f"[dim]Attaching to {target}... (Ctrl+b d to detach)[/dim]")
                     os.execvp("tmux", ["tmux", "attach", "-t", target])
@@ -2154,6 +2588,16 @@ def agents_resume(
                     **_execution_kwargs(launcher.resume, execution_mode.value if execution_mode else None),
                 )
 
+        if _already_running(session, resume_started):
+            name_val = session.terminal_name or session.tmux_window
+            label = f"{session.session_id[:8]}" + (f" ({escape(name_val)})" if name_val else "")
+            console.print(
+                f"This conversation is already running in {label}: attach with "
+                f"[bold]qbraid agents attach {session.session_id}[/bold]",
+                highlight=False,
+            )
+            return
+
         status_val = (
             "starting / check terminal"
             if _startup_pending(session)
@@ -2372,65 +2816,6 @@ def _entry_style(entry_type: str) -> str:
     return styles.get(entry_type, "")
 
 
-def _check_permission_prompt(tmux_session: str, tmux_window: str) -> Optional[list[str]]:
-    """Read the tmux pane and check for a permission prompt.
-
-    Returns a list of option strings if a prompt is detected, None otherwise.
-    """
-    import subprocess
-
-    result = subprocess.run(
-        ["tmux", "capture-pane", "-t", f"{tmux_session}:{tmux_window}", "-p", "-S", "-60"],
-        capture_output=True,
-        text=True,
-        check=False,
-    )
-    if result.returncode != 0:
-        return None
-
-    pane_text = result.stdout
-
-    # Look for Claude's permission prompt markers
-    if "Do you want to" not in pane_text and "Allow" not in pane_text:
-        return None
-
-    # Extract numbered options using regex — handles ANSI/unicode prefixes
-    # Claude's format: "❯ 1. Yes" / "  2. Yes, allow..." / "  3. No"
-    # Options may wrap across multiple lines in the terminal.
-    options: list[str] = []
-    pane_lines = pane_text.splitlines()
-    for i, line in enumerate(pane_lines):
-        match = re.search(r"(\d+)\.\s+(.+)", line)
-        if match:
-            num = int(match.group(1))
-            text = match.group(2).strip()
-            if num == len(options) + 1 and text:
-                # Collect continuation lines (lines until next numbered option,
-                # blank line, or "Esc to cancel" marker)
-                for j in range(i + 1, len(pane_lines)):
-                    cont = pane_lines[j].strip()
-                    if not cont or re.search(r"^\d+\.", cont) or "Esc to cancel" in cont:
-                        break
-                    text += " " + cont
-                options.append(f"{num}. {text}")
-
-    return options if options else None
-
-
-def _send_permission_choice(tmux_session: str, tmux_window: str, choice_idx: int) -> None:
-    """Send arrow key presses and Enter to select a permission option."""
-    import subprocess
-
-    target = f"{tmux_session}:{tmux_window}"
-
-    # Arrow down from position 1 (default) to the chosen option
-    for _ in range(choice_idx):
-        subprocess.run(["tmux", "send-keys", "-t", target, "Down"], check=False)
-        time.sleep(0.05)
-
-    subprocess.run(["tmux", "send-keys", "-t", target, "Enter"], check=False)
-
-
 @agents_app.command("watch")
 def agents_watch(
     session_id: str = typer.Argument(..., help="Session ID (prefix match)"),
@@ -2899,6 +3284,13 @@ def agents_attach(
             JupyterRuntimeClient(session.metadata["jupyter_server_id"]).attach(session)
             return
 
+        # A row recorded in another PID namespace, boot or Lab names a window
+        # that may now be someone else's: never attached to by name.
+        foreign = _foreign_pid_reason(session)
+        if foreign:
+            console.print(f"[red]Not attached:[/red] {escape(foreign)}", highlight=False)
+            raise typer.Exit(code=1)
+
         tmux_session = session.tmux_session
         tmux_window = session.tmux_window
 

{qbraid_cli-0.16.9 → qbraid_cli-0.16.10/qbraid_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qbraid-cli
-Version: 0.16.9
+Version: 0.16.10
 Summary: Command Line Interface for interacting with all parts of the qBraid platform.
 Author-email: qBraid Development Team <contact@qbraid.com>
 License-Expression: LicenseRef-Proprietary
@@ -30,11 +30,11 @@ Requires-Dist: typer>=0.12.1
 Requires-Dist: rich>=10.11.0
 Requires-Dist: click<=8.5.0
 Requires-Dist: questionary>=2.0.0
-Requires-Dist: qbraid-core>=0.6.21
+Requires-Dist: qbraid-core>=0.6.27
 Provides-Extra: compute
-Requires-Dist: qbraid-core[compute]>=0.6.21; extra == "compute"
+Requires-Dist: qbraid-core[compute]>=0.6.27; extra == "compute"
 Provides-Extra: envs
-Requires-Dist: qbraid-core[environments]>=0.6.21; extra == "envs"
+Requires-Dist: qbraid-core[environments]>=0.6.27; extra == "envs"
 Provides-Extra: dev
 Requires-Dist: isort; extra == "dev"
 Requires-Dist: black; extra == "dev"

{qbraid_cli-0.16.9 → qbraid_cli-0.16.10}/qbraid_cli.egg-info/requires.txt

@@ -2,10 +2,10 @@ typer>=0.12.1
 rich>=10.11.0
 click<=8.5.0
 questionary>=2.0.0
-qbraid-core>=0.6.21
+qbraid-core>=0.6.27
 
 [compute]
-qbraid-core[compute]>=0.6.21
+qbraid-core[compute]>=0.6.27
 
 [dev]
 isort
@@ -15,4 +15,4 @@ pytest-cov
 pytest-asyncio
 
 [envs]
-qbraid-core[environments]>=0.6.21
+qbraid-core[environments]>=0.6.27

{qbraid_cli-0.16.9 → qbraid_cli-0.16.10}/tests/test_cli_e2e.py

@@ -935,15 +935,20 @@ class TestAgentsE2E:
 
         assert result.exit_code == 1
 
+    @patch("qbraid_core.services.agents.AgentLauncher")
     @patch("qbraid_core.services.agents.AgentSessionRegistryManager")
-    def test_kill_session(self, mock_registry_cls):
-        """Kill a session by ID."""
+    def test_kill_session(self, mock_registry_cls, mock_launcher_cls):
+        """Kill a session by ID: a tmux row goes through Core's verified kill."""
         mock_session = MagicMock()
         mock_session.session_id = "abc12345-6789"
         mock_session.tmux_window = "worker-0"
         mock_session.terminal_name = None
         mock_session.pid = 12345
         mock_session.compute_id = None
+        mock_session.machine_id = None
+        mock_session.cluster_id = None
+        mock_session.metadata = {}
+        mock_session.status.value = "idle"
         mock_session.tmux_session = "qbraid-agents"
 
         mock_registry = MagicMock()
@@ -954,9 +959,14 @@ class TestAgentsE2E:
 
         from qbraid_cli.agents.app import agents_app
 
-        result = runner.invoke(agents_app, ["kill", "abc12345"])
+        with patch("subprocess.run") as tmux, patch("os.kill") as kill:
+            result = runner.invoke(agents_app, ["kill", "abc12345"])
 
-        assert result.exit_code == 0
+        assert result.exit_code == 0, result.output
+        mock_launcher_cls.return_value.kill_bound.assert_called_once_with("abc12345-6789")
+        # Nothing touches the window or the PID directly: Core verified the target.
+        tmux.assert_not_called()
+        kill.assert_not_called()
 
     @patch("qbraid_core.services.agents.AgentSessionRegistryManager")
     def test_discover_empty(self, mock_registry_cls):