pocketshell 0.4.18__tar.gz → 0.4.20__tar.gz

{pocketshell-0.4.18 → pocketshell-0.4.20}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pocketshell
-Version: 0.4.18
+Version: 0.4.20
 Summary: Unified server-side Python utility for the PocketShell Android client.
 Project-URL: Homepage, https://github.com/alexeygrigorev/pocketshell
 Project-URL: Issues, https://github.com/alexeygrigorev/pocketshell/issues

{pocketshell-0.4.18 → pocketshell-0.4.20}/pyproject.toml

@@ -8,7 +8,7 @@ name = "pocketshell"
 # scripts/check-pypi-version.sh enforces this; .github/workflows/build.yml
 # runs that check before publishing to PyPI. See
 # tools/pocketshell/README.md ("Release flow") for the bump procedure.
-version = "0.4.18"
+version = "0.4.20"
 description = "Unified server-side Python utility for the PocketShell Android client."
 readme = "README.md"
 requires-python = ">=3.11"

{pocketshell-0.4.18 → pocketshell-0.4.20}/src/pocketshell/agents.py

@@ -74,7 +74,11 @@ from __future__ import annotations
 import json
 import os
 import shutil
+import sqlite3
 import subprocess
+import sys
+import time
+import uuid
 from pathlib import Path
 from typing import Optional
 
@@ -442,6 +446,215 @@ def record_agent_kind(
     return True
 
 
+def _encode_agent_cwd(cwd: str) -> str:
+    trimmed = cwd.strip()
+    return trimmed.replace("/", "-").replace(".", "-") if trimmed else "-"
+
+
+def _codex_file_cwd(path: Path) -> Optional[str]:
+    try:
+        with path.open("r", encoding="utf-8", errors="replace") as handle:
+            for line in handle:
+                if '"session_meta"' not in line or '"cwd"' not in line:
+                    continue
+                row = json.loads(line)
+                payload = row.get("payload")
+                if row.get("type") == "session_meta" and isinstance(payload, dict):
+                    cwd = payload.get("cwd")
+                    return cwd if isinstance(cwd, str) else None
+    except Exception:
+        return None
+    return None
+
+
+def _path_mtime(path: Path) -> float:
+    try:
+        return path.stat().st_mtime
+    except OSError:
+        return 0.0
+
+
+def _latest_claude_source(cwd: str, started_at: float) -> Optional[str]:
+    root = Path.home() / ".claude" / "projects" / _encode_agent_cwd(cwd)
+    if not root.is_dir():
+        return None
+    candidates = [
+        path
+        for path in root.glob("*.jsonl")
+        if path.is_file() and _path_mtime(path) >= started_at
+    ]
+    if not candidates:
+        return None
+    return str(max(candidates, key=_path_mtime))
+
+
+def _latest_codex_source(cwd: str, started_at: float) -> Optional[str]:
+    root = Path.home() / ".codex" / "sessions"
+    if not root.is_dir():
+        return None
+    candidates = [
+        path
+        for path in root.rglob("*.jsonl")
+        if path.is_file()
+        and _path_mtime(path) >= started_at
+        and _codex_file_cwd(path) == cwd
+    ]
+    if not candidates:
+        return None
+    return str(max(candidates, key=_path_mtime))
+
+
+def _latest_opencode_source(cwd: str, started_at: float) -> Optional[str]:
+    db = Path.home() / ".local" / "share" / "opencode" / "opencode.db"
+    if not db.is_file():
+        return None
+    normalized_cwd = cwd.rstrip("/") or "/"
+    started_ms = int(started_at * 1000)
+    query = """
+        SELECT s.id, COALESCE(s.time_updated, s.time_created, 0),
+               COALESCE(p.worktree, ''), COALESCE(s.directory, '')
+        FROM session s
+        LEFT JOIN project p ON p.id = s.project_id
+        WHERE COALESCE(s.time_updated, s.time_created, 0) >= ?
+        ORDER BY COALESCE(s.time_updated, s.time_created, 0) DESC
+    """
+    try:
+        with sqlite3.connect(f"file:{db}?mode=ro", uri=True) as conn:
+            rows = conn.execute(query, (started_ms,)).fetchall()
+    except Exception:
+        return None
+    for session_id, _updated, worktree, directory in rows:
+        for candidate_cwd in (worktree, directory):
+            if not candidate_cwd:
+                continue
+            root = str(candidate_cwd).rstrip("/") or "/"
+            if normalized_cwd == root or normalized_cwd.startswith(root + "/"):
+                return f"{db}#{session_id}"
+    return None
+
+
+def _latest_agent_source(
+    kind: str,
+    cwd: str,
+    started_at: float,
+) -> Optional[str]:
+    if kind == "claude":
+        return _latest_claude_source(cwd, started_at)
+    if kind == "codex":
+        return _latest_codex_source(cwd, started_at)
+    if kind == "opencode":
+        return _latest_opencode_source(cwd, started_at)
+    return None
+
+
+def _watch_and_record_agent_source(
+    kind: str,
+    cwd: str,
+    started_at: str,
+    generation: str,
+    timeout_seconds: str = "20",
+) -> int:
+    """Watch for this launch's transcript and record it on the tmux session.
+
+    The wrapper starts this helper immediately before ``execvpe``. The agent
+    process has not minted its transcript id yet, so this runs in a detached
+    host-side child and records ``@ps_agent_source`` once the source appears.
+    """
+    try:
+        started = float(started_at)
+        timeout = float(timeout_seconds)
+    except ValueError:
+        return 2
+    deadline = time.monotonic() + max(timeout, 0.0)
+    while time.monotonic() <= deadline:
+        source = _latest_agent_source(kind, cwd, started)
+        if source:
+            try:
+                current_generation = subprocess.run(
+                    ["tmux", "show-options", "-v", "@ps_agent_source_generation"],
+                    check=False,
+                    stdout=subprocess.PIPE,
+                    stderr=subprocess.DEVNULL,
+                    text=True,
+                ).stdout.strip()
+                if current_generation != generation:
+                    return 1
+                subprocess.run(
+                    ["tmux", "set-option", "@ps_agent_source", f"{generation}\t{source}"],
+                    check=False,
+                    stdout=subprocess.DEVNULL,
+                    stderr=subprocess.DEVNULL,
+                )
+                return 0
+            except Exception:
+                return 1
+        time.sleep(0.25)
+    return 1
+
+
+def record_agent_source(
+    kind: str,
+    cwd: str,
+    env: Optional[dict[str, str]] = None,
+    runner=None,
+    popen=None,
+) -> bool:
+    """Start a best-effort recorder for this launch's transcript source.
+
+    ``@ps_agent_kind`` records the engine at launch. This sibling option records
+    the exact transcript identity once the launched CLI has created it, so the
+    Android conversation opener can prefer an exact source over same-kind mtime
+    selection. The old source option is cleared first; if the watcher never
+    finds a transcript, the client falls back to its current selector instead of
+    trusting a stale path from a previous relaunch in the same tmux session.
+    """
+    if not kind or not cwd:
+        return False
+    source_env = os.environ if env is None else env
+    if not source_env.get("TMUX"):
+        return False
+    if runner is None:
+        runner = subprocess.run
+    if popen is None:
+        popen = subprocess.Popen
+    try:
+        generation = uuid.uuid4().hex
+        runner(
+            ["tmux", "set-option", "@ps_agent_source_generation", generation],
+            check=False,
+        )
+        runner(
+            ["tmux", "set-option", "-uq", "@ps_agent_source"],
+            check=False,
+        )
+        started_at = str(time.time() - 1.0)
+        popen(
+            [
+                sys.executable,
+                "-c",
+                (
+                    "from pocketshell.agents import "
+                    "_watch_and_record_agent_source; import sys; "
+                    "raise SystemExit(_watch_and_record_agent_source("
+                    "sys.argv[1], sys.argv[2], sys.argv[3], sys.argv[4]))"
+                ),
+                kind,
+                cwd,
+                started_at,
+                generation,
+            ],
+            env=dict(source_env),
+            stdin=subprocess.DEVNULL,
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+            close_fds=True,
+            start_new_session=True,
+        )
+    except Exception:
+        return False
+    return True
+
+
 def launch_agent(
     ctx: click.Context,
     kind: str,
@@ -453,6 +666,7 @@ def launch_agent(
     profile: Optional[str] = None,
     execvpe=None,
     record_kind=None,
+    record_source=None,
 ) -> None:
     """Resolve the dir, build env+argv, suppress prompts, exec the agent.
 
@@ -482,6 +696,8 @@ def launch_agent(
         execvpe = os.execvpe
     if record_kind is None:
         record_kind = record_agent_kind
+    if record_source is None:
+        record_source = record_agent_source
 
     path = _resolve_dir(ctx, directory)
     resolved_dir = str(path)
@@ -517,6 +733,7 @@ def launch_agent(
     # environment (os.environ) for the TMUX detection — `env` is the
     # provider-stripped launch env that does not necessarily carry $TMUX.
     record_kind(kind, dict(os.environ), profile=profile)
+    record_source(kind, resolved_dir, dict(os.environ))
 
     # Replace this process with the agent so it owns the pty cleanly.
     execvpe(argv[0], argv, env)

{pocketshell-0.4.18 → pocketshell-0.4.20}/tests/test_agents.py

@@ -17,6 +17,7 @@ from __future__ import annotations
 
 import json
 import os
+import sys
 
 import click
 import pytest
@@ -58,6 +59,20 @@ def _restore_cwd():
         os.chdir(original)
 
 
+class _FakePopen:
+    pid = 12345
+
+
+@pytest.fixture(autouse=True)
+def _no_source_recorder_child(monkeypatch):
+    """Keep launch tests from spawning the background source watcher."""
+    monkeypatch.setattr(
+        agents.subprocess,
+        "Popen",
+        lambda *args, **kwargs: _FakePopen(),
+    )
+
+
 # ---------------------------------------------------------------------------
 # Env-strip scope: ALL three agents strip the 71 provider vars (issue #703)
 # ---------------------------------------------------------------------------
@@ -512,6 +527,168 @@ def test_record_agent_kind_swallows_runner_failure():
     assert ok is False
 
 
+def test_record_agent_source_noop_when_not_in_tmux(tmp_path):
+    calls = []
+    ok = agents.record_agent_source(
+        "claude",
+        str(tmp_path),
+        env={},
+        runner=lambda argv, **kw: calls.append(argv),
+        popen=lambda *a, **kw: calls.append(a),
+    )
+    assert ok is False
+    assert calls == []
+
+
+def test_record_agent_source_clears_stale_source_and_starts_watcher(tmp_path):
+    run_calls = []
+    popen_calls = []
+
+    ok = agents.record_agent_source(
+        "codex",
+        str(tmp_path),
+        env={"TMUX": "/tmp/tmux-1000/default,1234,0", "PATH": "/usr/bin"},
+        runner=lambda argv, **kw: run_calls.append((argv, kw)),
+        popen=lambda *args, **kwargs: popen_calls.append((args, kwargs)) or _FakePopen(),
+    )
+
+    assert ok is True
+    generation = run_calls[0][0][-1]
+    assert run_calls[0][0] == ["tmux", "set-option", "@ps_agent_source_generation", generation]
+    assert len(generation) == 32
+    assert run_calls[0][1] == {"check": False}
+    assert run_calls[1] == (
+        ["tmux", "set-option", "-uq", "@ps_agent_source"],
+        {"check": False},
+    )
+    assert len(popen_calls) == 1
+    argv = popen_calls[0][0][0]
+    assert argv[:2] == [sys.executable, "-c"]
+    assert argv[3:5] == ["codex", str(tmp_path)]
+    assert argv[6] == generation
+    assert popen_calls[0][1]["env"]["TMUX"] == "/tmp/tmux-1000/default,1234,0"
+
+
+def test_watch_agent_source_refuses_stale_generation(monkeypatch):
+    calls = []
+    monkeypatch.setattr(
+        agents,
+        "_latest_agent_source",
+        lambda kind, cwd, started_at: "/tmp/current.jsonl",
+    )
+
+    def fake_run(argv, **kwargs):
+        calls.append((argv, kwargs))
+        if argv[:3] == ["tmux", "show-options", "-v"]:
+            return agents.subprocess.CompletedProcess(argv, 0, stdout="newer-generation\n")
+        return agents.subprocess.CompletedProcess(argv, 0, stdout="")
+
+    monkeypatch.setattr(agents.subprocess, "run", fake_run)
+
+    assert agents._watch_and_record_agent_source(
+        "claude",
+        "/workspace/proj",
+        "100",
+        "older-generation",
+        timeout_seconds="0.01",
+    ) == 1
+    assert calls == [
+        (
+            ["tmux", "show-options", "-v", "@ps_agent_source_generation"],
+            {
+                "check": False,
+                "stdout": agents.subprocess.PIPE,
+                "stderr": agents.subprocess.DEVNULL,
+                "text": True,
+            },
+        )
+    ]
+
+
+def test_watch_agent_source_records_generation_scoped_source(monkeypatch):
+    calls = []
+    monkeypatch.setattr(
+        agents,
+        "_latest_agent_source",
+        lambda kind, cwd, started_at: "/tmp/current.jsonl",
+    )
+
+    def fake_run(argv, **kwargs):
+        calls.append((argv, kwargs))
+        if argv[:3] == ["tmux", "show-options", "-v"]:
+            return agents.subprocess.CompletedProcess(argv, 0, stdout="same-generation\n")
+        return agents.subprocess.CompletedProcess(argv, 0, stdout="")
+
+    monkeypatch.setattr(agents.subprocess, "run", fake_run)
+
+    assert agents._watch_and_record_agent_source(
+        "claude",
+        "/workspace/proj",
+        "100",
+        "same-generation",
+        timeout_seconds="0.01",
+    ) == 0
+    assert calls[-1][0] == [
+        "tmux",
+        "set-option",
+        "@ps_agent_source",
+        "same-generation\t/tmp/current.jsonl",
+    ]
+
+
+def test_latest_claude_source_encodes_dot_cwd_like_android_detector(tmp_path, monkeypatch):
+    monkeypatch.setenv("HOME", str(tmp_path))
+    cwd = "/workspace/app.1"
+    log_dir = tmp_path / ".claude" / "projects" / "-workspace-app-1"
+    log_dir.mkdir(parents=True)
+    transcript = log_dir / "session.jsonl"
+    transcript.write_text("new\n", encoding="utf-8")
+    os.utime(transcript, (300, 300))
+
+    assert agents._latest_agent_source("claude", cwd, started_at=200) == str(transcript)
+
+
+def test_latest_claude_source_ignores_prelaunch_sibling(tmp_path, monkeypatch):
+    monkeypatch.setenv("HOME", str(tmp_path))
+    cwd = "/workspace/proj"
+    log_dir = tmp_path / ".claude" / "projects" / "-workspace-proj"
+    log_dir.mkdir(parents=True)
+    older = log_dir / "older.jsonl"
+    newer = log_dir / "newer.jsonl"
+    older.write_text("old\n", encoding="utf-8")
+    newer.write_text("new\n", encoding="utf-8")
+    os.utime(older, (100, 100))
+    os.utime(newer, (300, 300))
+
+    assert agents._latest_agent_source("claude", cwd, started_at=200) == str(newer)
+
+
+def test_latest_codex_source_matches_cwd_and_launch_time(tmp_path, monkeypatch):
+    monkeypatch.setenv("HOME", str(tmp_path))
+    root = tmp_path / ".codex" / "sessions" / "2026" / "06" / "27"
+    root.mkdir(parents=True)
+    mine = root / "rollout-mine.jsonl"
+    sibling = root / "rollout-sibling.jsonl"
+    stale = root / "rollout-stale.jsonl"
+    mine.write_text(
+        """{"type":"session_meta","payload":{"cwd":"/workspace/proj"}}\n""",
+        encoding="utf-8",
+    )
+    sibling.write_text(
+        """{"type":"session_meta","payload":{"cwd":"/workspace/other"}}\n""",
+        encoding="utf-8",
+    )
+    stale.write_text(
+        """{"type":"session_meta","payload":{"cwd":"/workspace/proj"}}\n""",
+        encoding="utf-8",
+    )
+    os.utime(mine, (300, 300))
+    os.utime(sibling, (400, 400))
+    os.utime(stale, (100, 100))
+
+    assert agents._latest_agent_source("codex", "/workspace/proj", started_at=200) == str(mine)
+
+
 @pytest.mark.parametrize("kind", ["claude", "codex", "opencode"])
 def test_launch_agent_records_kind_before_exec(tmp_path, monkeypatch, kind):
     monkeypatch.setenv("HOME", str(tmp_path))
@@ -525,6 +702,10 @@ def test_launch_agent_records_kind_before_exec(tmp_path, monkeypatch, kind):
     def fake_execvpe(file, argv, env):
         order.append(("exec", file))
 
+    def fake_record_source(k, cwd, env=None, runner=None, popen=None):
+        order.append(("source", k, cwd, env.get("TMUX") if env else None))
+        return True
+
     agents.launch_agent(
         _FakeCtx(),
         kind,
@@ -533,11 +714,12 @@ def test_launch_agent_records_kind_before_exec(tmp_path, monkeypatch, kind):
         config_dir=None,
         execvpe=fake_execvpe,
         record_kind=fake_record,
+        record_source=fake_record_source,
     )
-    # The kind is recorded with the wrapper's own $TMUX, and recorded BEFORE
-    # the exec replaces the process.
+    # The kind/source are recorded with the wrapper's own $TMUX before exec.
     assert order == [
         ("record", kind, "/tmp/tmux-1000/default,1234,0"),
+        ("source", kind, str(tmp_path), "/tmp/tmux-1000/default,1234,0"),
         ("exec", kind),
     ]
 
@@ -684,6 +866,7 @@ def test_launch_agent_records_profile_before_exec(tmp_path, monkeypatch):
         profile="Claude (Z.AI)",
         execvpe=lambda f, a, e: None,
         record_kind=fake_record,
+        record_source=lambda *a, **kw: True,
     )
     assert recorded == {"kind": "claude", "profile": "Claude (Z.AI)"}
 
@@ -692,7 +875,7 @@ def test_cli_agent_named_profile_records_profile_option(tmp_path, monkeypatch):
     """End-to-end #858: launching claude via the z.ai profile inside tmux
     writes BOTH @ps_agent_kind=claude AND @ps_agent_profile=<name> before
     exec, via the real --profile resolution path."""
-    home = _seed_zlaude_home(tmp_path, monkeypatch)
+    _seed_zlaude_home(tmp_path, monkeypatch)
     workdir = tmp_path / "work"
     workdir.mkdir()
     monkeypatch.setenv("TMUX", "/tmp/tmux-1000/default,1234,0")
@@ -793,7 +976,8 @@ def test_cli_agent_default_then_zai_relaunch_sets_profile(tmp_path, monkeypatch)
     )
     assert ["tmux", "set-option", "@ps_agent_profile", "Claude (Z.AI)"] in zai_calls
     assert not any(
-        argv[:3] == ["tmux", "set-option", "-uq"] for argv in zai_calls
+        argv[:4] == ["tmux", "set-option", "-uq", "@ps_agent_profile"]
+        for argv in zai_calls
     )