kuzywrap 0.1.72__py3-none-any.whl

kuzywrap-0.1.72.data/data/lib/kuzywrap/antigravity.py

@@ -0,0 +1,631 @@
+"""Tmux-backed Antigravity wrapper (Option 1).
+
+Runs Google's native `agy` CLI inside a dedicated tmux session
+(`kuzywrap-antigravity-<target>`). Managed chat attaches directly to tmux,
+giving the operator the full native Antigravity TUI (Markdown, colored diffs,
+thinking blocks, interactive tool approvals, slash commands).
+
+Inject submits prompts via a private tmux paste buffer and Enter key,
+recording all turns in a local SQLite3 journal for durability and auditability.
+"""
+from __future__ import annotations
+
+import argparse
+from contextlib import contextmanager
+import hashlib
+import json
+import math
+import os
+from pathlib import Path
+import re
+import shlex
+import shutil
+import sqlite3
+import subprocess
+import sys
+import tarfile
+import tempfile
+import time
+import urllib.request
+import uuid
+
+RUNTIME = "antigravity"
+TMUX_SESSION_PREFIX = "kuzywrap-antigravity"
+DEFAULT_EFFORT = "high"
+MAX_LINE = 4 * 1024 * 1024
+
+
+class Error(Exception):
+    def __init__(self, code: str, message: str, *, retryable: bool = False, details: dict | None = None):
+        super().__init__(message)
+        self.code, self.retryable, self.details = code, retryable, details or {}
+
+    def payload(self) -> dict:
+        data = {
+            "ok": False,
+            "status": "failed",
+            "runtime": RUNTIME,
+            "error_code": self.code,
+            "message": str(self),
+            "retryable": self.retryable,
+            "error": {"code": self.code, "message": str(self)},
+        }
+        if self.details:
+            data["error"]["details"] = self.details
+        return data
+
+
+def safe_target(value: str) -> str:
+    if not re.fullmatch(r"[a-zA-Z0-9][a-zA-Z0-9_.-]{0,47}", value):
+        raise argparse.ArgumentTypeError("Target must be 1-48 letters, digits, dots, dashes or underscores.")
+    return value
+
+
+def session_id(value: str) -> str:
+    if not re.fullmatch(r"[a-zA-Z0-9-]{32,128}", value):
+        raise argparse.ArgumentTypeError("Expected a native Antigravity conversation ID (32-128 letters/digits/dashes).")
+    return value
+
+
+def positive_timeout(value: str) -> float:
+    result = float(value)
+    if not math.isfinite(result) or result <= 0:
+        raise argparse.ArgumentTypeError("Timeout must be finite and positive.")
+    return result
+
+
+def config_root() -> Path:
+    return Path(os.environ.get("XDG_CONFIG_HOME", Path.home() / ".config")) / "kuzywrap" / RUNTIME
+
+
+def state_root() -> Path:
+    return Path(os.environ.get("XDG_STATE_HOME", Path.home() / ".local/state")) / "kuzywrap" / RUNTIME
+
+
+def paths(target: str) -> dict[str, Path]:
+    state = state_root() / target
+    return {
+        "config": config_root() / "targets" / f"{target}.json",
+        "state": state,
+        "log": state / "runtime.log",
+        "journal": state / "journal.sqlite3",
+    }
+
+
+def load_config(target: str) -> dict:
+    path = paths(target)["config"]
+    if not path.exists():
+        raise Error("target_missing", f"Configure target first: kuzywrap-antigravity target set {target} --current-user --cd PATH")
+    return json.loads(path.read_text(encoding="utf-8"))
+
+
+def tmux_session_name(target: str) -> str:
+    return f"{TMUX_SESSION_PREFIX}-{target}"
+
+
+def _tmux_run(args: list[str], *, input: str | None = None) -> subprocess.CompletedProcess[str]:
+    return subprocess.run(
+        ["tmux", *args],
+        input=input,
+        capture_output=True,
+        text=True,
+    )
+
+
+def tmux_has_session(session: str) -> bool:
+    res = _tmux_run(["has-session", "-t", session])
+    return res.returncode == 0
+
+
+class Journal:
+    def __init__(self, path: Path):
+        self.path = path
+        self.path.parent.mkdir(parents=True, exist_ok=True, mode=0o700)
+        with sqlite3.connect(self.path) as db:
+            db.execute("CREATE TABLE IF NOT EXISTS meta (key TEXT PRIMARY KEY, value TEXT NOT NULL)")
+            db.execute("""CREATE TABLE IF NOT EXISTS turns (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                request_id TEXT UNIQUE NOT NULL,
+                prompt TEXT NOT NULL,
+                source TEXT NOT NULL,
+                status TEXT NOT NULL,
+                response TEXT,
+                error TEXT,
+                submitted_at REAL NOT NULL,
+                updated_at REAL NOT NULL
+            )""")
+            db.execute("""CREATE TABLE IF NOT EXISTS events (
+                seq INTEGER PRIMARY KEY AUTOINCREMENT,
+                turn_id INTEGER,
+                status TEXT NOT NULL,
+                timestamp REAL NOT NULL
+            )""")
+
+    def record_turn(self, *, request_id: str, prompt: str, source: str, status: str = "accepted") -> int:
+        now = time.time()
+        with sqlite3.connect(self.path) as db:
+            cursor = db.cursor()
+            cursor.execute(
+                "INSERT OR REPLACE INTO turns (request_id, prompt, source, status, submitted_at, updated_at) VALUES (?, ?, ?, ?, ?, ?)",
+                (request_id, prompt, source, status, now, now),
+            )
+            turn_id = cursor.lastrowid
+            cursor.execute("INSERT INTO events (turn_id, status, timestamp) VALUES (?, ?, ?)", (turn_id, status, now))
+            db.commit()
+            return turn_id
+
+    def events(self, after: int = 0, limit: int = 100) -> list[dict]:
+        with sqlite3.connect(self.path) as db:
+            cursor = db.cursor()
+            cursor.execute("""
+                SELECT e.seq, e.turn_id, e.status, e.timestamp, t.request_id, t.prompt, t.source, t.response, t.error
+                FROM events e JOIN turns t ON e.turn_id = t.id
+                WHERE e.seq > ? ORDER BY e.seq ASC LIMIT ?
+            """, (after, limit))
+            rows = cursor.fetchall()
+            return [
+                {
+                    "seq": r[0], "id": r[1], "event_status": r[2], "timestamp": r[3],
+                    "request_id": r[4], "prompt": r[5], "source": r[6], "response": r[7], "error": r[8]
+                }
+                for r in rows
+            ]
+
+    def last_seq(self) -> int:
+        with sqlite3.connect(self.path) as db:
+            cursor = db.cursor()
+            cursor.execute("SELECT COALESCE(MAX(seq), 0) FROM events")
+            row = cursor.fetchone()
+            return row[0] if row else 0
+
+    def get_meta(self, key: str) -> str | None:
+        with sqlite3.connect(self.path) as db:
+            cursor = db.cursor()
+            cursor.execute("SELECT value FROM meta WHERE key = ?", (key,))
+            row = cursor.fetchone()
+            return row[0] if row else None
+
+    def set_meta(self, key: str, value: str) -> None:
+        with sqlite3.connect(self.path) as db:
+            db.execute("INSERT OR REPLACE INTO meta (key, value) VALUES (?, ?)", (key, str(value)))
+
+
+def build_agy_cmd(config: dict) -> list[str]:
+    binary = config.get("binary") or shutil.which("agy") or str(Path.home() / ".local/bin/agy")
+    cmd = [binary]
+    session = config.get("session_id")
+    if session:
+        cmd += ["--conversation", session]
+    else:
+        cmd += ["--continue"]
+
+    model = config.get("model")
+    effort = config.get("effort")
+    if model:
+        cmd += ["--model", model]
+        if not effort and model.startswith("gemini"):
+            effort = DEFAULT_EFFORT
+    if effort:
+        cmd += ["--effort", effort]
+
+    if config.get("agent"):
+        cmd += ["--agent", config["agent"]]
+    if config.get("skip_permissions"):
+        cmd += ["--dangerously-skip-permissions"]
+
+    return cmd
+
+
+def start(target: str) -> dict:
+    config = load_config(target)
+    session = tmux_session_name(target)
+    if tmux_has_session(session):
+        return {
+            "ok": True,
+            "runtime": RUNTIME,
+            "target": target,
+            "state": "running",
+            "tmux_session": session,
+            "session_id": config.get("session_id"),
+            "already_running": True,
+        }
+
+    loc = paths(target)
+    loc["state"].mkdir(parents=True, exist_ok=True, mode=0o700)
+    workdir = Path(config.get("workdir", Path.cwd())).resolve()
+    if not workdir.is_dir():
+        raise Error("invalid_workdir", f"Working directory does not exist: {workdir}")
+
+    binary = config.get("binary") or shutil.which("agy") or str(Path.home() / ".local/bin/agy")
+    if not Path(binary).is_file():
+        raise Error("binary_missing", f"No upstream binary at {binary}. Install Antigravity CLI first.")
+
+    cmd = build_agy_cmd(config)
+    inner = " ".join(shlex.quote(p) for p in cmd)
+
+    spawn = _tmux_run(["new-session", "-d", "-s", session, "-c", str(workdir), inner])
+    if spawn.returncode != 0:
+        err = spawn.stderr.strip() or spawn.stdout.strip()
+        raise Error("startup_failed", f"Failed to start tmux session {session}: {err}")
+
+    _tmux_run(["pipe-pane", "-t", session, "-o", f"cat >> {shlex.quote(str(loc['log']))}"])
+
+    deadline = time.monotonic() + 3.0
+    alive = False
+    while time.monotonic() < deadline:
+        if tmux_has_session(session):
+            alive = True
+            break
+        time.sleep(0.1)
+
+    if not alive:
+        log_tail = ""
+        if loc["log"].exists():
+            log_tail = loc["log"].read_text(encoding="utf-8")[-400:]
+        raise Error("startup_failed", f"Runtime died immediately after startup. Log: {log_tail}")
+
+    return {
+        "ok": True,
+        "runtime": RUNTIME,
+        "target": target,
+        "state": "running",
+        "session_id": config.get("session_id"),
+        "tmux_session": session,
+        "capabilities": {
+            "inject": True,
+            "steer": True,
+            "native_tui_attach": True,
+        },
+    }
+
+
+def stop(target: str) -> dict:
+    session = tmux_session_name(target)
+    if tmux_has_session(session):
+        _tmux_run(["kill-session", "-t", session])
+    return {
+        "ok": True,
+        "runtime": RUNTIME,
+        "target": target,
+        "state": "stopped",
+        "stopping": True,
+    }
+
+
+def status(target: str) -> dict:
+    session = tmux_session_name(target)
+    running = tmux_has_session(session)
+    config = {}
+    try:
+        config = load_config(target)
+    except Exception:
+        pass
+    return {
+        "ok": True,
+        "runtime": RUNTIME,
+        "target": target,
+        "state": "running" if running else "stopped",
+        "tmux_session": session,
+        "session_id": config.get("session_id"),
+    }
+
+
+def chat(target: str, *, session_id: str | None = None, cd: str | None = None) -> int:
+    config = load_config(target)
+    session = tmux_session_name(target)
+    if cd and str(Path(cd).resolve()) != config.get("workdir"):
+        raise Error("workdir_mismatch", "Chat directory differs from configured target.")
+    if session_id and config.get("session_id") and session_id != config.get("session_id"):
+        raise Error("session_mismatch", "Chat anchor differs from configured target.")
+
+    if not tmux_has_session(session):
+        start(target)
+
+    res = subprocess.run(["tmux", "attach-session", "-t", session])
+    return res.returncode
+
+
+def inject(
+    target: str,
+    prompt: str,
+    *,
+    wait_mode: str = "accepted",
+    timeout: float = 30.0,
+    request_id: str | None = None,
+    prompt_source: str = "argv",
+) -> dict:
+    session = tmux_session_name(target)
+    if not tmux_has_session(session):
+        raise Error(
+            "runtime_inactive",
+            f"No tmux session {session!r} running for target {target!r}. Start it first with 'kuzywrap-antigravity start {target}'.",
+        )
+
+    if not prompt.strip():
+        raise Error("prompt_empty", "Prompt cannot be empty.")
+
+    buf_name = f"kuzywrap-antigravity-{target}-{os.getpid()}-{int(time.time() * 1000)}"
+    prompt_to_paste = prompt.rstrip("\r\n")
+    load_res = _tmux_run(["load-buffer", "-b", buf_name, "-"], input=prompt_to_paste)
+    if load_res.returncode != 0:
+        raise Error("buffer_load_failed", f"tmux load-buffer failed: {load_res.stderr.strip()}")
+
+    paste_res = _tmux_run(["paste-buffer", "-p", "-r", "-d", "-b", buf_name, "-t", session])
+    if paste_res.returncode != 0:
+        _tmux_run(["delete-buffer", "-b", buf_name])
+        raise Error("buffer_paste_failed", f"tmux paste-buffer failed: {paste_res.stderr.strip()}")
+
+    enter_res = _tmux_run(["send-keys", "-t", session, "Enter"])
+    if enter_res.returncode != 0:
+        raise Error("send_keys_failed", f"tmux send-keys failed: {enter_res.stderr.strip()}")
+
+    loc = paths(target)
+    journal = Journal(loc["journal"])
+    req_id = request_id or uuid.uuid4().hex
+    turn_id = journal.record_turn(request_id=req_id, prompt=prompt, source=prompt_source, status="accepted")
+
+    config = {}
+    try:
+        config = load_config(target)
+    except Exception:
+        pass
+
+    return {
+        "ok": True,
+        "runtime": RUNTIME,
+        "target": target,
+        "status": "accepted",
+        "wait_mode": wait_mode,
+        "delivery_mode": "tmux_paste_buffer",
+        "tmux_session": session,
+        "injection_id": turn_id,
+        "request_id": req_id,
+        "session_id": config.get("session_id"),
+        "submitted_at": time.time(),
+    }
+
+
+def install_upstream(directory: str, *, dry_run: bool = False) -> dict:
+    arch = {"x86_64": "amd64", "aarch64": "arm64"}.get(os.uname().machine)
+    if sys.platform != "linux" or not arch:
+        raise Error("unsupported_platform", "This installer supports Linux x86_64 and aarch64 only.")
+    suffix = "_musl" if any(Path("/lib").glob("libc.musl-*.so.1")) else ""
+    url = f"https://antigravity-cli-auto-updater-974169037036.us-central1.run.app/manifests/linux_{arch}{suffix}.json"
+    destination = Path(directory).expanduser().resolve() / "agy"
+    if dry_run:
+        return {"manifest": url, "destination": str(destination), "verification": "SHA-512", "shell_profiles_modified": False}
+    destination.parent.mkdir(parents=True, exist_ok=True)
+    if destination.exists() or destination.is_symlink():
+        raise Error("already_installed", f"Refusing to overwrite {destination}. Use upgrade for an existing installation.")
+    with urllib.request.urlopen(url, timeout=30) as response:
+        manifest = json.load(response)
+    download = manifest["url"]
+    expected = manifest["sha512"]
+    if not download.startswith("https://storage.googleapis.com/antigravity-public/antigravity-cli/") or not re.fullmatch(r"[0-9a-f]{128}", expected):
+        raise Error("invalid_manifest", "Unexpected download origin or checksum in official manifest.")
+    with tempfile.TemporaryDirectory(prefix="agy-install-", dir=destination.parent) as tmp:
+        archive = Path(tmp) / "archive"
+        digest = hashlib.sha512()
+        with urllib.request.urlopen(download, timeout=60) as response, archive.open("wb") as output:
+            while chunk := response.read(1024 * 1024):
+                digest.update(chunk)
+                output.write(chunk)
+        if digest.hexdigest() != expected:
+            raise Error("checksum_mismatch", "Downloaded Antigravity archive failed SHA-512 verification.")
+        staged = Path(tmp) / "agy"
+        with tarfile.open(archive, "r:gz") as package:
+            member = package.getmember("antigravity")
+            member.name = "agy"
+            package.extract(member, tmp)
+        staged.chmod(0o755)
+        staged.replace(destination)
+    return {"ok": True, "installed": str(destination), "manifest": url}
+
+
+def parser() -> argparse.ArgumentParser:
+    root = argparse.ArgumentParser(prog="kuzywrap-antigravity", description="Tmux-backed Google Antigravity stream wrapper.")
+    sub = root.add_subparsers(dest="command", required=True)
+
+    install = sub.add_parser("install")
+    install.add_argument("dir", default=str(Path.home() / ".local/bin"), nargs="?")
+    install.add_argument("--dry-run", action="store_true")
+
+    target = sub.add_parser("target").add_subparsers(dest="action", required=True)
+    setting = target.add_parser("set")
+    setting.add_argument("target", type=safe_target)
+    setting.add_argument("--current-user", action="store_true", required=True)
+    setting.add_argument("--cd")
+    setting.add_argument("--binary")
+    setting.add_argument("--session-id", type=session_id)
+    setting.add_argument("--model")
+    setting.add_argument("--agent")
+    setting.add_argument("--display-name")
+    setting.add_argument("--effort", choices=["low", "medium", "high", "xhigh", "max"])
+    setting.add_argument("--dangerously-skip-permissions", action="store_true", default=None)
+
+    for action in ("show", "list", "unset"):
+        p = target.add_parser(action)
+        if action in ("show", "unset"):
+            p.add_argument("target", type=safe_target)
+        p.add_argument("--json", action="store_true")
+
+    for action in ("start", "stop", "restart", "status", "paths", "chat", "sync-status", "verify", "doctor"):
+        p = sub.add_parser(action)
+        p.add_argument("target", type=safe_target)
+        p.add_argument("--json", action="store_true")
+        if action == "chat":
+            p.add_argument("--session-id", type=session_id)
+            p.add_argument("--cd")
+        if action == "sync-status":
+            p.add_argument("--after", type=int)
+            p.add_argument("--limit", type=int, default=100)
+            p.add_argument("--ack", type=int, metavar="CURSOR")
+
+    inject_parser = sub.add_parser("inject")
+    inject_parser.add_argument("target", type=safe_target)
+    inject_parser.add_argument("prompt", nargs="+")
+    inject_parser.add_argument("--wait", choices=["accepted", "completed"], default="accepted")
+    inject_parser.add_argument("--no-wait", action="store_true", help="Return immediately after submission.")
+    inject_parser.add_argument("--timeout", type=positive_timeout)
+    inject_parser.add_argument("--request-id", help="Stable idempotency key.")
+    inject_parser.add_argument("--session-id", type=session_id)
+
+    sub.add_parser("version")
+    sub.add_parser("upgrade")
+    return root
+
+
+def execute(args: argparse.Namespace):
+    command = args.command
+    if command == "install":
+        return install_upstream(args.dir, dry_run=args.dry_run)
+    if command in ("version", "upgrade"):
+        binary = shutil.which("agy") or str(Path.home() / ".local/bin/agy")
+        if not shutil.which("agy") and not Path(binary).exists():
+            raise Error("runtime_missing", "Antigravity binary not found. Install it first: kuzywrap-antigravity install")
+        return subprocess.call([binary, "--version" if command == "version" else "update"])
+
+    if command == "target":
+        if args.action == "list":
+            configs = []
+            targets_dir = config_root() / "targets"
+            if targets_dir.exists():
+                for p in sorted(targets_dir.glob("*.json")):
+                    try:
+                        configs.append(json.loads(p.read_text(encoding="utf-8")))
+                    except Exception:
+                        pass
+            return {"targets": configs}
+
+        if args.action == "show":
+            return load_config(args.target)
+
+        if args.action == "unset":
+            path = paths(args.target)["config"]
+            if path.exists():
+                path.unlink()
+            return {"ok": True, "unset": args.target}
+
+        # target set
+        path = paths(args.target)["config"]
+        path.parent.mkdir(parents=True, exist_ok=True, mode=0o700)
+        old = json.loads(path.read_text(encoding="utf-8")) if path.exists() else {}
+        record = dict(old, target=args.target, kind="current-user")
+        record.setdefault("binary", shutil.which("agy") or str(Path.home() / ".local/bin/agy"))
+        record.setdefault("workdir", str(Path.cwd()))
+        for flag, key in (
+            ("cd", "workdir"),
+            ("binary", "binary"),
+            ("session_id", "session_id"),
+            ("model", "model"),
+            ("agent", "agent"),
+            ("effort", "effort"),
+            ("display_name", "display_name"),
+            ("dangerously_skip_permissions", "skip_permissions"),
+        ):
+            value = getattr(args, flag, None)
+            if value is not None:
+                record[key] = str(Path(value).expanduser().resolve()) if key in ("workdir", "binary") else value
+
+        if not Path(record["workdir"]).is_dir():
+            raise Error("invalid_workdir", "Working directory must already exist.")
+
+        path.write_text(json.dumps(record, indent=2) + "\n", encoding="utf-8")
+        path.chmod(0o600)
+        return record
+
+    target = getattr(args, "target", None)
+    if command == "start":
+        return start(target)
+    if command == "stop":
+        return stop(target)
+    if command == "restart":
+        stop(target)
+        return start(target)
+    if command == "status":
+        return status(target)
+    if command == "paths":
+        return {k: str(v) for k, v in paths(target).items()}
+
+    if command == "chat":
+        return chat(target, session_id=args.session_id, cd=args.cd)
+
+    if command == "inject":
+        stdin = args.prompt == ["-"]
+        prompt = sys.stdin.read(MAX_LINE // 2) if stdin else " ".join(args.prompt)
+        mode = "accepted" if args.no_wait else args.wait
+        timeout = args.timeout or 30.0
+        return inject(
+            target,
+            prompt,
+            wait_mode=mode,
+            timeout=timeout,
+            request_id=args.request_id,
+            prompt_source="stdin" if stdin else "argv",
+        )
+
+    if command == "sync-status":
+        loc = paths(target)
+        journal = Journal(loc["journal"])
+        if args.ack is not None:
+            journal.set_meta("ack_cursor", str(args.ack))
+            return {"ok": True, "ack_cursor": args.ack}
+        after = args.after
+        if after is None:
+            after = int(journal.get_meta("ack_cursor") or 0)
+        evs = journal.events(after=after, limit=args.limit)
+        cfg = {}
+        try:
+            cfg = load_config(target)
+        except Exception:
+            pass
+        return {
+            "ok": True,
+            "events": evs,
+            "cursor": evs[-1]["seq"] if evs else after,
+            "last_seq": journal.last_seq(),
+            "session_id": cfg.get("session_id"),
+        }
+
+    if command in ("verify", "doctor"):
+        cfg = {}
+        target_ok = False
+        try:
+            cfg = load_config(target)
+            target_ok = True
+        except Exception:
+            pass
+        tmux_ok = shutil.which("tmux") is not None
+        agy_ok = shutil.which("agy") is not None or Path(cfg.get("binary", "")).is_file()
+        running = tmux_has_session(tmux_session_name(target)) if target_ok else False
+        return {
+            "ok": tmux_ok and agy_ok and target_ok,
+            "target": target,
+            "configured": target_ok,
+            "running": running,
+            "tmux_available": tmux_ok,
+            "agy_available": agy_ok,
+            "runtime": RUNTIME,
+        }
+
+    raise Error("unknown_command", command)
+
+
+def main(argv=None) -> int:
+    os.umask(0o077)
+    args = parser().parse_args(argv)
+    try:
+        result = execute(args)
+    except Error as exc:
+        result = exc.payload()
+    except (OSError, ValueError, KeyError, sqlite3.Error) as exc:
+        result = Error("runtime_error", str(exc)).payload()
+
+    if isinstance(result, int):
+        return result
+    print(json.dumps(result, indent=2))
+    return 0 if result.get("ok", True) else 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

kuzywrap-0.1.72.data/data/lib/kuzywrap/claude-runtime

@@ -0,0 +1,17 @@
+#!/bin/sh
+set -eu
+
+# kuzywrap-claude persistent runtime launcher.
+#
+# Step 1 of the Claude-side scope (kuzys/process/CLAUDE_SIDE_SCOPE.md) ships
+# this helper as an explicit stub. The systemd unit kuzywrap-claude@.service
+# is installed for packaging symmetry with kuzywrap-codex, but starting it
+# fails until Step 2 decides how to keep a Remote-Control-aware claude session
+# alive under systemd (TTY allocation, login persistence, JWT refresh, etc).
+
+agent="${1:?agent instance name required}"
+
+echo "kuzywrap-claude: persistent service launch is not yet implemented." >&2
+echo "agent=${agent}" >&2
+echo "See: /usr/share/doc/kuzywrap-claude/README.md" >&2
+exit 78