agypywpr 0.1.0__tar.gz

agypywpr-0.1.0/LICENSE

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

agypywpr-0.1.0/PKG-INFO

@@ -0,0 +1,89 @@
+Metadata-Version: 2.4
+Name: agypywpr
+Version: 0.1.0
+Summary: Run Antigravity CLI tasks with temporary permission augmentation.
+Requires-Python: >=3.14
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == "dev"
+Requires-Dist: build>=1.2; extra == "dev"
+Dynamic: license-file
+
+# agypywpr
+
+`agypywpr` runs a one-shot Google Antigravity CLI task with temporary permission
+rules. It backs up `~/.gemini/antigravity-cli/settings.json`, augments the
+permission lists, runs `agy`, and restores the original settings afterward.
+
+## Installation
+
+Antigravity CLI must already be installed and authenticated as `agy`.
+
+```bash
+python3 -m pip install agypywpr
+```
+
+Run a prompt from a UTF-8 file:
+
+```bash
+agypywpr run --prompt-file prompt.txt --permissions-file permissions.json
+```
+
+Arguments after `--` are passed to `agy`:
+
+```bash
+agypywpr run --prompt-file prompt.txt -- --model gemini
+```
+
+The default timeout is 30 minutes. Use `--timeout SECONDS` to override it.
+
+## Permission file
+
+The permission file contains an additive fragment. Existing settings are not
+replaced.
+
+```json
+{
+  "permissions": {
+    "allow": ["command(git)", "write_file(src/)"],
+    "deny": ["command(sudo)"],
+    "ask": ["command(*)"]
+  }
+}
+```
+
+Rules are deduplicated within each list. Antigravity evaluates conflicting
+rules using its documented precedence: deny, then ask, then allow.
+
+## Recovery
+
+The wrapper uses a lock, a mode-`0600` recovery journal, and atomic settings
+writes. If the process is forcibly killed, inspect the settings and run:
+
+```bash
+agypywpr restore
+```
+
+The current release targets Linux and macOS. The completion behavior for
+background Antigravity subagents is under compatibility testing because AGY's
+headless completion protocol is not documented.
+
+## Development
+
+```bash
+.venv/bin/python -m pip install --editable '.[dev]'
+.venv/bin/python -m unittest discover -s tests -v
+```
+
+Build the wheel and source distribution from the repository root:
+
+```bash
+.venv/bin/python -m build
+```
+
+## Publishing
+
+Releases are published from GitHub through PyPI Trusted Publishing (OIDC).
+Configure a protected `pypi` GitHub Environment and register the repository's
+pending Trusted Publisher on PyPI before creating a release tag.

agypywpr-0.1.0/README.md

@@ -0,0 +1,77 @@
+# agypywpr
+
+`agypywpr` runs a one-shot Google Antigravity CLI task with temporary permission
+rules. It backs up `~/.gemini/antigravity-cli/settings.json`, augments the
+permission lists, runs `agy`, and restores the original settings afterward.
+
+## Installation
+
+Antigravity CLI must already be installed and authenticated as `agy`.
+
+```bash
+python3 -m pip install agypywpr
+```
+
+Run a prompt from a UTF-8 file:
+
+```bash
+agypywpr run --prompt-file prompt.txt --permissions-file permissions.json
+```
+
+Arguments after `--` are passed to `agy`:
+
+```bash
+agypywpr run --prompt-file prompt.txt -- --model gemini
+```
+
+The default timeout is 30 minutes. Use `--timeout SECONDS` to override it.
+
+## Permission file
+
+The permission file contains an additive fragment. Existing settings are not
+replaced.
+
+```json
+{
+  "permissions": {
+    "allow": ["command(git)", "write_file(src/)"],
+    "deny": ["command(sudo)"],
+    "ask": ["command(*)"]
+  }
+}
+```
+
+Rules are deduplicated within each list. Antigravity evaluates conflicting
+rules using its documented precedence: deny, then ask, then allow.
+
+## Recovery
+
+The wrapper uses a lock, a mode-`0600` recovery journal, and atomic settings
+writes. If the process is forcibly killed, inspect the settings and run:
+
+```bash
+agypywpr restore
+```
+
+The current release targets Linux and macOS. The completion behavior for
+background Antigravity subagents is under compatibility testing because AGY's
+headless completion protocol is not documented.
+
+## Development
+
+```bash
+.venv/bin/python -m pip install --editable '.[dev]'
+.venv/bin/python -m unittest discover -s tests -v
+```
+
+Build the wheel and source distribution from the repository root:
+
+```bash
+.venv/bin/python -m build
+```
+
+## Publishing
+
+Releases are published from GitHub through PyPI Trusted Publishing (OIDC).
+Configure a protected `pypi` GitHub Environment and register the repository's
+pending Trusted Publisher on PyPI before creating a release tag.

agypywpr-0.1.0/pyproject.toml

@@ -0,0 +1,29 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "agypywpr"
+version = "0.1.0"
+description = "Run Antigravity CLI tasks with temporary permission augmentation."
+readme = "README.md"
+requires-python = ">=3.14"
+dependencies = []
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8",
+    "build>=1.2",
+]
+
+[project.scripts]
+agypywpr = "tools.cli:main"
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

agypywpr-0.1.0/setup.cfg

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

agypywpr-0.1.0/src/agypywpr.egg-info/PKG-INFO

@@ -0,0 +1,89 @@
+Metadata-Version: 2.4
+Name: agypywpr
+Version: 0.1.0
+Summary: Run Antigravity CLI tasks with temporary permission augmentation.
+Requires-Python: >=3.14
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == "dev"
+Requires-Dist: build>=1.2; extra == "dev"
+Dynamic: license-file
+
+# agypywpr
+
+`agypywpr` runs a one-shot Google Antigravity CLI task with temporary permission
+rules. It backs up `~/.gemini/antigravity-cli/settings.json`, augments the
+permission lists, runs `agy`, and restores the original settings afterward.
+
+## Installation
+
+Antigravity CLI must already be installed and authenticated as `agy`.
+
+```bash
+python3 -m pip install agypywpr
+```
+
+Run a prompt from a UTF-8 file:
+
+```bash
+agypywpr run --prompt-file prompt.txt --permissions-file permissions.json
+```
+
+Arguments after `--` are passed to `agy`:
+
+```bash
+agypywpr run --prompt-file prompt.txt -- --model gemini
+```
+
+The default timeout is 30 minutes. Use `--timeout SECONDS` to override it.
+
+## Permission file
+
+The permission file contains an additive fragment. Existing settings are not
+replaced.
+
+```json
+{
+  "permissions": {
+    "allow": ["command(git)", "write_file(src/)"],
+    "deny": ["command(sudo)"],
+    "ask": ["command(*)"]
+  }
+}
+```
+
+Rules are deduplicated within each list. Antigravity evaluates conflicting
+rules using its documented precedence: deny, then ask, then allow.
+
+## Recovery
+
+The wrapper uses a lock, a mode-`0600` recovery journal, and atomic settings
+writes. If the process is forcibly killed, inspect the settings and run:
+
+```bash
+agypywpr restore
+```
+
+The current release targets Linux and macOS. The completion behavior for
+background Antigravity subagents is under compatibility testing because AGY's
+headless completion protocol is not documented.
+
+## Development
+
+```bash
+.venv/bin/python -m pip install --editable '.[dev]'
+.venv/bin/python -m unittest discover -s tests -v
+```
+
+Build the wheel and source distribution from the repository root:
+
+```bash
+.venv/bin/python -m build
+```
+
+## Publishing
+
+Releases are published from GitHub through PyPI Trusted Publishing (OIDC).
+Configure a protected `pypi` GitHub Environment and register the repository's
+pending Trusted Publisher on PyPI before creating a release tag.

agypywpr-0.1.0/src/agypywpr.egg-info/SOURCES.txt

@@ -0,0 +1,16 @@
+LICENSE
+README.md
+pyproject.toml
+src/agypywpr.egg-info/PKG-INFO
+src/agypywpr.egg-info/SOURCES.txt
+src/agypywpr.egg-info/dependency_links.txt
+src/agypywpr.egg-info/entry_points.txt
+src/agypywpr.egg-info/requires.txt
+src/agypywpr.egg-info/top_level.txt
+src/tools/__init__.py
+src/tools/cli.py
+src/tools/permissions.py
+src/tools/runner.py
+src/tools/settings.py
+tests/test_permissions.py
+tests/test_runner.py

agypywpr-0.1.0/src/agypywpr.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

agypywpr-0.1.0/src/agypywpr.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+agypywpr = tools.cli:main

agypywpr-0.1.0/src/agypywpr.egg-info/requires.txt

@@ -0,0 +1,4 @@
+
+[dev]
+pytest>=8
+build>=1.2

agypywpr-0.1.0/src/agypywpr.egg-info/top_level.txt

@@ -0,0 +1 @@
+tools

agypywpr-0.1.0/src/tools/__init__.py

@@ -0,0 +1 @@
+"""Reusable components for the agypywpr command-line application."""

agypywpr-0.1.0/src/tools/cli.py

@@ -0,0 +1,59 @@
+"""Command-line entry point for agypywpr."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+from pathlib import Path
+
+from .permissions import PermissionConfigError, parse_permission_document
+from .runner import RunnerError, run_agy
+from .settings import SettingsError, SettingsTransaction, restore_from_journal
+
+DEFAULT_SETTINGS = Path.home() / ".gemini" / "antigravity-cli" / "settings.json"
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(prog="agypywpr")
+    subparsers = parser.add_subparsers(dest="command", required=True)
+    run_parser = subparsers.add_parser("run", help="run one Antigravity prompt")
+    run_parser.add_argument("--prompt-file", type=Path, required=True)
+    run_parser.add_argument("--permissions-file", type=Path)
+    run_parser.add_argument("--timeout", type=float, default=1800)
+    run_parser.add_argument("--", dest="agy_arguments", nargs=argparse.REMAINDER)
+    restore_parser = subparsers.add_parser("restore", help="restore a pending settings transaction")
+    restore_parser.add_argument("--settings-path", type=Path, default=DEFAULT_SETTINGS)
+    return parser
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = build_parser().parse_args(argv)
+    try:
+        if args.command == "restore":
+            restore_from_journal(args.settings_path.expanduser())
+            return 0
+        return _run(args)
+    except (OSError, ValueError, PermissionConfigError, SettingsError, RunnerError) as error:
+        print(f"agypywpr: {error}", file=os.sys.stderr)
+        return 2
+
+
+def _run(args: argparse.Namespace) -> int:
+    prompt = args.prompt_file.read_text(encoding="utf-8")
+    additions = {"allow": [], "deny": [], "ask": []}
+    if args.permissions_file is not None:
+        additions = parse_permission_document(
+            json.loads(args.permissions_file.read_text(encoding="utf-8"))
+        )
+    settings_path = DEFAULT_SETTINGS
+    arguments = args.agy_arguments or []
+    with SettingsTransaction(settings_path, additions):
+        result = run_agy(prompt, arguments, timeout=args.timeout)
+    if result.timed_out:
+        return 124
+    return result.returncode
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

agypywpr-0.1.0/src/tools/permissions.py

@@ -0,0 +1,55 @@
+"""Validation and augmentation of Antigravity permission settings."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any
+
+
+PERMISSION_CATEGORIES = ("allow", "deny", "ask")
+
+
+class PermissionConfigError(ValueError):
+    """Raised when a permissions document has an invalid shape."""
+
+
+def parse_permission_document(document: Any) -> dict[str, list[str]]:
+    """Validate and normalize a permissions document."""
+    if not isinstance(document, Mapping):
+        raise PermissionConfigError("permissions document must be an object")
+    permissions = document.get("permissions", document)
+    if not isinstance(permissions, Mapping):
+        raise PermissionConfigError("permissions must be an object")
+    unknown = set(permissions) - set(PERMISSION_CATEGORIES)
+    if unknown:
+        raise PermissionConfigError(
+            f"unknown permission categories: {', '.join(sorted(unknown))}"
+        )
+
+    result: dict[str, list[str]] = {}
+    for category in PERMISSION_CATEGORIES:
+        values = permissions.get(category, [])
+        if not isinstance(values, list) or not all(
+            isinstance(value, str) for value in values
+        ):
+            raise PermissionConfigError(f"permissions.{category} must be a list of strings")
+        result[category] = list(dict.fromkeys(values))
+    return result
+
+
+def augment_permissions(settings: Mapping[str, Any], additions: Mapping[str, list[str]]) -> dict[str, Any]:
+    """Return settings with unique temporary rules appended to each category."""
+    result = dict(settings)
+    current = settings.get("permissions", {})
+    if not isinstance(current, Mapping):
+        raise PermissionConfigError("settings.permissions must be an object")
+    merged = dict(current)
+    for category in PERMISSION_CATEGORIES:
+        existing = current.get(category, [])
+        if not isinstance(existing, list) or not all(
+            isinstance(value, str) for value in existing
+        ):
+            raise PermissionConfigError(f"settings.permissions.{category} must be a list of strings")
+        merged[category] = list(dict.fromkeys([*existing, *additions[category]]))
+    result["permissions"] = merged
+    return result

agypywpr-0.1.0/src/tools/runner.py

@@ -0,0 +1,73 @@
+"""Subprocess supervision for the Antigravity CLI."""
+
+from __future__ import annotations
+
+import os
+import signal
+import subprocess
+import time
+from typing import Sequence
+
+
+class RunnerError(RuntimeError):
+    """Raised when the Antigravity process cannot be started or completed."""
+
+
+class RunResult:
+    """Result of an Antigravity process."""
+
+    def __init__(self, returncode: int, timed_out: bool = False) -> None:
+        self.returncode = returncode
+        self.timed_out = timed_out
+
+
+def run_agy(
+    prompt: str,
+    arguments: Sequence[str],
+    *,
+    executable: str = "agy",
+    timeout: float = 1800,
+) -> RunResult:
+    """Run one prompt while keeping stdin open until the child exits."""
+    command = [executable, "-p", prompt, *arguments]
+    process_group = os.setsid if os.name != "nt" else None
+    try:
+        process = subprocess.Popen(
+            command,
+            stdin=subprocess.PIPE,
+            stdout=None,
+            stderr=None,
+            start_new_session=process_group is not None,
+            text=True,
+        )
+    except OSError as error:
+        raise RunnerError(f"could not start {executable}: {error}") from error
+
+    deadline = time.monotonic() + timeout
+    try:
+        while process.poll() is None:
+            if time.monotonic() >= deadline:
+                _stop_process(process)
+                return RunResult(process.wait(), timed_out=True)
+            time.sleep(0.1)
+        return RunResult(process.returncode or 0)
+    except KeyboardInterrupt:
+        _stop_process(process)
+        raise
+    finally:
+        if process.stdin is not None:
+            process.stdin.close()
+
+
+def _stop_process(process: subprocess.Popen[str]) -> None:
+    """Gracefully stop a child process group, then force it if necessary."""
+    try:
+        if os.name != "nt":
+            os.killpg(process.pid, signal.SIGINT)
+        else:
+            process.send_signal(getattr(signal, "CTRL_BREAK_EVENT", signal.SIGINT))
+        process.wait(timeout=5)
+    except (ProcessLookupError, subprocess.TimeoutExpired):
+        if process.poll() is None:
+            process.kill()
+            process.wait()

agypywpr-0.1.0/src/tools/settings.py

@@ -0,0 +1,141 @@
+"""Transactional Antigravity settings updates."""
+
+from __future__ import annotations
+
+import json
+import os
+import tempfile
+from pathlib import Path
+from types import TracebackType
+from typing import Any
+
+from .permissions import augment_permissions
+
+
+class SettingsError(RuntimeError):
+    """Raised when settings cannot be safely updated or restored."""
+
+
+class SettingsTransaction:
+    """Temporarily augment settings and restore their original bytes on exit."""
+
+    def __init__(self, path: Path, additions: dict[str, list[str]]) -> None:
+        self.path = path.expanduser()
+        self.additions = additions
+        self.lock_path = self.path.with_name(f".{self.path.name}.agypywpr.lock")
+        self.journal_path = self.path.with_name(f".{self.path.name}.agypywpr-journal")
+        self._lock_file: Any = None
+        self._original: bytes | None = None
+        self._temporary: bytes | None = None
+
+    def __enter__(self) -> "SettingsTransaction":
+        self.path.parent.mkdir(parents=True, exist_ok=True)
+        if self.journal_path.exists():
+            raise SettingsError(f"recovery journal exists: {self.journal_path}")
+        try:
+            self._lock_file = self.lock_path.open("x", encoding="ascii")
+        except FileExistsError as error:
+            raise SettingsError(f"settings are already locked: {self.path}") from error
+        try:
+            existed = self.path.exists()
+            self._original = self.path.read_bytes() if existed else None
+            settings = json.loads(self._original or b"{}")
+            updated = augment_permissions(settings, self.additions)
+            self.journal_path.write_text(
+                json.dumps({"existed": existed, "original": self._original.decode("utf-8") if self._original else None}),
+                encoding="utf-8",
+            )
+            self.journal_path.chmod(0o600)
+            self._atomic_write(updated)
+            self._temporary = self.path.read_bytes()
+            return self
+        except Exception:
+            self._cleanup_lock()
+            raise
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        traceback: TracebackType | None,
+    ) -> None:
+        try:
+            self.restore()
+        finally:
+            self._cleanup_lock()
+
+    def restore(self) -> None:
+        """Restore the exact bytes present before the transaction."""
+        if self.path.exists() and self._temporary is not None:
+            current = self.path.read_bytes()
+            if current != self._temporary:
+                raise SettingsError(
+                    "settings changed during the run; use agypywpr restore after review"
+                )
+        if self._original is None:
+            if self.path.exists():
+                self.path.unlink()
+        else:
+            self._atomic_write_bytes(self._original)
+        if self.journal_path.exists():
+            self.journal_path.unlink()
+
+    def _atomic_write(self, settings: dict[str, Any]) -> None:
+        payload = json.dumps(settings, indent=2, ensure_ascii=False) + "\n"
+        self._atomic_write_bytes(payload.encode("utf-8"))
+
+    def _atomic_write_bytes(self, payload: bytes) -> None:
+        mode = self.path.stat().st_mode & 0o777 if self.path.exists() else 0o600
+        descriptor, temporary = tempfile.mkstemp(dir=self.path.parent, prefix=f".{self.path.name}.")
+        try:
+            os.fchmod(descriptor, mode)
+            with os.fdopen(descriptor, "wb") as stream:
+                stream.write(payload)
+                stream.flush()
+                os.fsync(stream.fileno())
+            os.replace(temporary, self.path)
+        finally:
+            if os.path.exists(temporary):
+                os.unlink(temporary)
+
+    def _cleanup_lock(self) -> None:
+        if self._lock_file is not None:
+            self._lock_file.close()
+            self._lock_file = None
+        try:
+            self.lock_path.unlink()
+        except FileNotFoundError:
+            pass
+
+
+def restore_from_journal(path: Path) -> None:
+    """Restore a settings file from a durable interrupted-run journal."""
+    path = path.expanduser()
+    journal_path = path.with_name(f".{path.name}.agypywpr-journal")
+    if not journal_path.exists():
+        raise SettingsError(f"no recovery journal exists: {journal_path}")
+    try:
+        journal = json.loads(journal_path.read_text(encoding="utf-8"))
+        original = journal["original"]
+        existed = journal["existed"]
+    except (OSError, KeyError, TypeError, json.JSONDecodeError) as error:
+        raise SettingsError(f"invalid recovery journal: {journal_path}") from error
+    if existed:
+        if not isinstance(original, str):
+            raise SettingsError("recovery journal does not contain original settings")
+        payload = original.encode("utf-8")
+        mode = path.stat().st_mode & 0o777 if path.exists() else 0o600
+        descriptor, temporary = tempfile.mkstemp(dir=path.parent, prefix=f".{path.name}.")
+        try:
+            os.fchmod(descriptor, mode)
+            with os.fdopen(descriptor, "wb") as stream:
+                stream.write(payload)
+                stream.flush()
+                os.fsync(stream.fileno())
+            os.replace(temporary, path)
+        finally:
+            if os.path.exists(temporary):
+                os.unlink(temporary)
+    elif path.exists():
+        path.unlink()
+    journal_path.unlink()

agypywpr-0.1.0/tests/test_permissions.py

@@ -0,0 +1,36 @@
+import json
+import tempfile
+import unittest
+from pathlib import Path
+
+from tools.permissions import PermissionConfigError, augment_permissions, parse_permission_document
+from tools.settings import SettingsTransaction
+
+
+class PermissionTests(unittest.TestCase):
+    def test_parse_and_merge_preserves_existing_rules(self) -> None:
+        additions = parse_permission_document(
+            {"permissions": {"allow": ["command(git)", "command(git)"], "deny": ["command(sudo)"]}}
+        )
+        settings = {"colorScheme": "terminal", "permissions": {"allow": ["command(make)"]}}
+        merged = augment_permissions(settings, additions)
+        self.assertEqual(merged["permissions"]["allow"], ["command(make)", "command(git)"])
+        self.assertEqual(merged["permissions"]["deny"], ["command(sudo)"])
+        self.assertEqual(settings["colorScheme"], "terminal")
+
+    def test_rejects_unknown_category(self) -> None:
+        with self.assertRaises(PermissionConfigError):
+            parse_permission_document({"permissions": {"read": []}})
+
+    def test_transaction_restores_exact_bytes(self) -> None:
+        with tempfile.TemporaryDirectory() as directory:
+            path = Path(directory) / "settings.json"
+            original = b'{"permissions":{"allow":[]},"custom":true}\n'
+            path.write_bytes(original)
+            with SettingsTransaction(path, {"allow": ["command(git)"], "deny": [], "ask": []}):
+                self.assertEqual(json.loads(path.read_text())["permissions"]["allow"], ["command(git)"])
+            self.assertEqual(path.read_bytes(), original)
+
+
+if __name__ == "__main__":
+    unittest.main()

agypywpr-0.1.0/tests/test_runner.py

@@ -0,0 +1,39 @@
+import stat
+import tempfile
+import unittest
+from pathlib import Path
+
+from tools.runner import run_agy
+
+
+class RunnerTests(unittest.TestCase):
+    def _script(self, directory: str, body: str) -> Path:
+        path = Path(directory) / "fake-agy"
+        path.write_text(f"#!/bin/sh\n{body}\n", encoding="utf-8")
+        path.chmod(path.stat().st_mode | stat.S_IXUSR)
+        return path
+
+    def test_keeps_stdin_open_until_child_exits(self) -> None:
+        with tempfile.TemporaryDirectory() as directory:
+            executable = self._script(
+                directory,
+                """[ "$1" = "-p" ] && [ "$2" = "prompt" ]
+                [ "$3" = "--model" ] && [ "$4" = "test" ]
+                exit 7""",
+            )
+            result = run_agy(
+                "prompt", ["--model", "test"], executable=str(executable), timeout=2
+            )
+            self.assertEqual(result.returncode, 7)
+            self.assertFalse(result.timed_out)
+
+    def test_timeout_stops_child(self) -> None:
+        with tempfile.TemporaryDirectory() as directory:
+            executable = self._script(directory, "sleep 30")
+            result = run_agy("prompt", [], executable=str(executable), timeout=0.1)
+            self.assertTrue(result.timed_out)
+            self.assertNotEqual(result.returncode, 0)
+
+
+if __name__ == "__main__":
+    unittest.main()