agentsquid 0.1.0__py3-none-any.whl

agent/config.py

@@ -0,0 +1,137 @@
+import getpass
+import hashlib
+import os
+import shutil
+import tempfile
+from pathlib import Path
+from typing import Optional
+import yaml
+
+_USER_CONFIG = Path.home() / ".squid" / "squid.yaml"
+_EXAMPLE_CONFIG = Path(__file__).parent.parent / "config" / "squid.yaml.example"
+
+
+def _bootstrap_config() -> None:
+    """Create ~/.squid/squid.yaml from the bundled example on first run.
+
+    bin/install.sh and bin/start.sh do this same substitution for a source
+    checkout, but a pip/pipx install never runs either script, so this has
+    to also happen here — otherwise a fresh pipx install has no config file
+    and _load_config() below crashes on the very first launch.
+    """
+    if _USER_CONFIG.exists() or not _EXAMPLE_CONFIG.exists():
+        return
+    _USER_CONFIG.parent.mkdir(parents=True, exist_ok=True)
+    text = _EXAMPLE_CONFIG.read_text(encoding="utf-8")
+    text = text.replace("/tmp/squid", f"/tmp/{getpass.getuser()}/squid")
+    _USER_CONFIG.write_text(text, encoding="utf-8")
+
+
+def _load_config() -> dict:
+    _bootstrap_config()
+    return yaml.safe_load(_USER_CONFIG.read_text())
+
+
+def config_text() -> str:
+    return _USER_CONFIG.read_text(encoding="utf-8")
+
+
+def config_revision(content: Optional[str] = None) -> str:
+    raw = config_text() if content is None else content
+    return hashlib.sha256(raw.encode("utf-8")).hexdigest()[:16]
+
+
+def write_config_text(content: str, expected_revision: Optional[str] = None) -> str:
+    """Atomically replace squid.yaml, retaining the previous version as .bak."""
+    if expected_revision is not None and config_revision() != expected_revision:
+        raise RuntimeError("configuration changed since it was loaded")
+
+    mode = _USER_CONFIG.stat().st_mode & 0o777
+    backup = _USER_CONFIG.with_suffix(_USER_CONFIG.suffix + ".bak")
+    shutil.copy2(_USER_CONFIG, backup)
+    fd, tmp_name = tempfile.mkstemp(prefix=".squid.yaml.", dir=_USER_CONFIG.parent)
+    try:
+        with os.fdopen(fd, "w", encoding="utf-8") as handle:
+            handle.write(content)
+            handle.flush()
+            os.fsync(handle.fileno())
+        os.chmod(tmp_name, mode)
+        os.replace(tmp_name, _USER_CONFIG)
+    finally:
+        if os.path.exists(tmp_name):
+            os.unlink(tmp_name)
+    return config_revision(content)
+
+_cfg = _load_config()
+
+# CLI executable names — override via env if installed elsewhere
+CLAUDE_CLI    = "claude"
+CODEX_CLI     = "codex"
+CURSOR_CLI    = "cursor-agent"
+OPENCODE_CLI  = "opencode"
+PI_CLI        = "pi"
+
+# Experimental runners exist for these CLIs but they are not configurable harnesses.
+COPILOT_CLI  = "copilot"
+AGY_CLI      = "agy"
+
+# Squid Echo: a no-op harness (agent/runners.py's run_echo) that echoes the
+# prompt straight back with no subprocess and no network call — for fast,
+# free previews of how a Squid Flow route actually dispatches/executes
+# (joins, round-trips, broadcasts, ...) without a real coding-agent CLI in
+# the loop. Opt-in only (absent/false by default), so it never shows up for
+# a user who hasn't asked for it; harnesses.py and providers.py both gate on
+# this flag. Settable either way — `test_harness_enabled: true` in
+# squid.yaml (picked up on every restart, since /restart re-execs and
+# re-reads the file) or the SQUID_TEST_HARNESS env var (for CI/one-offs).
+TEST_HARNESS_ENABLED: bool = bool(_cfg.get("test_harness_enabled")) or bool(os.environ.get("SQUID_TEST_HARNESS"))
+
+# How long to wait for a CLI to produce its first byte before giving up
+FIRST_BYTE_TIMEOUT: int = _cfg["agent"]["first_byte_timeout"]
+
+# Hard cap on total response time per request
+RESPONSE_TIMEOUT: int = _cfg["agent"]["response_timeout"]
+
+def find_cli(name: str) -> Optional[str]:
+    return shutil.which(name)
+
+CLAUDE_PATH    = find_cli(CLAUDE_CLI)
+CODEX_PATH     = find_cli(CODEX_CLI)
+COPILOT_PATH   = find_cli(COPILOT_CLI)
+CURSOR_PATH    = find_cli(CURSOR_CLI)
+OPENCODE_PATH  = find_cli(OPENCODE_CLI)
+PI_PATH        = find_cli(PI_CLI)
+AGY_PATH       = find_cli(AGY_CLI)
+
+# OpenCode free provider — no API key required
+OPENCODE_DEFAULT_MODEL = "opencode/deepseek-v4-flash-free"
+
+# Per-user tmp dir for context sync — avoids cross-user permission conflicts
+SQUID_HOME = f"/tmp/{os.getlogin()}/squid"
+
+# Per-turn Git worktree isolation (see ADR-0025). On by default; set
+# `worktree.enabled: false` in squid.yaml to use direct working-tree writes.
+_worktree_cfg = _cfg.get("worktree", {})
+WORKTREE_ISOLATION_ENABLED: bool = bool(_worktree_cfg.get("enabled", True))
+WORKTREE_TRACK_DIRTY_CHANGES: bool = bool(_worktree_cfg.get("track_dirty_changes", False))
+
+# Dependency/cache directory names to symlink from a code root into each fresh
+# per-turn worktree. auto_link_ignored_dirs only links ignored dirs whose
+# basename appears in this allowlist.
+WORKTREE_AUTO_LINK_IGNORED_DIRS: bool = bool(_worktree_cfg.get("auto_link_ignored_dirs", True))
+DEPENDENCY_DIRS: list[str] = _worktree_cfg.get("dependency_dirs", [
+    "node_modules", ".venv", "venv", "env", ".tox", "__pypackages__",
+    "vendor", "target", ".bundle", "Pods", ".cargo", ".stack-work", "elm-stuff",
+])
+
+# Proxy environment to inject into every CLI subprocess, or None if disabled.
+_proxy_cfg = _cfg.get("proxy", {})
+PROXY_ENV: Optional[dict] = None
+if _proxy_cfg.get("enabled"):
+    _proxy_url = _proxy_cfg.get("url", "http://127.0.0.1:8080")
+    _cert = os.path.expanduser(_proxy_cfg.get("ssl_cert_file", "~/.mitmproxy/mitmproxy-ca-cert.pem"))
+    PROXY_ENV = {
+        "HTTP_PROXY": _proxy_url,
+        "HTTPS_PROXY": _proxy_url,
+        "SSL_CERT_FILE": _cert,
+    }

agent/context_sync.py

@@ -0,0 +1,163 @@
+"""
+context_sync.py — keep /tmp/<user>/squid in sync with squid/context/.
+
+The tmp dir cannot be a symlink to context/ because Claude Code resolves the
+real path, which would load CLAUDE.md and MCP config from the wrong scope.
+Instead we maintain it as a real directory and rsync into it.
+
+Strategy (Option 4):
+  - sync_now()   — blocking full sync; call once at daemon startup
+  - maybe_sync() — async stat-check; call before each prompt; only rsyncs
+                   when context/ has changed since the last sync
+"""
+
+import asyncio
+import json
+import logging
+import os
+import shutil
+import subprocess
+from pathlib import Path
+
+from .config import SQUID_HOME
+
+log = logging.getLogger(__name__)
+
+CONTEXT_DIR = str(Path.home() / ".squid" / "context")
+# Bundled default context (topics/roles seed content), shipped alongside
+# ui/ and config/ in the wheel (see pyproject.toml's force-include). Sibling
+# to this package the same way UI_DIR is in agent/server.py.
+_BUNDLED_CONTEXT = Path(__file__).parent.parent / "context"
+_last_sync_mtime: float = 0.0
+
+
+def _seed_context_if_empty() -> None:
+    """Copy the bundled default context/ into ~/.squid/context on first run.
+
+    bin/install.sh and bin/start.sh do this same "only if empty" copy for a
+    source checkout, but a pip/pipx install never runs either script, so
+    this has to also happen here — otherwise a fresh pipx install has no
+    default topics/roles content and nothing seeds it.
+    """
+    context_dir = Path(CONTEXT_DIR)
+    if context_dir.exists() and any(context_dir.iterdir()):
+        return
+    if not _BUNDLED_CONTEXT.exists():
+        return
+    context_dir.mkdir(parents=True, exist_ok=True)
+    shutil.copytree(_BUNDLED_CONTEXT, context_dir, dirs_exist_ok=True)
+_CODEX_MANAGED_BEGIN = "# BEGIN SQUID MANAGED MCP"
+_CODEX_MANAGED_END = "# END SQUID MANAGED MCP"
+
+
+def _rmdir_empty_parents(path: Path, stop: Path) -> None:
+    parent = path.parent
+    while parent != stop and parent.is_relative_to(stop):
+        try:
+            parent.rmdir()
+        except OSError:
+            return
+        parent = parent.parent
+
+
+def _remove_json_server(path: Path, section: str, empty_shape: dict, context_dir: Path) -> None:
+    if not path.exists():
+        return
+    try:
+        config = json.loads(path.read_text(encoding="utf-8"))
+    except json.JSONDecodeError:
+        return
+    if not isinstance(config, dict):
+        return
+    servers = config.get(section)
+    if not isinstance(servers, dict) or "squid" not in servers:
+        return
+    servers.pop("squid", None)
+    if config == empty_shape:
+        path.unlink()
+        _rmdir_empty_parents(path, context_dir)
+        return
+    path.write_text(json.dumps(config, indent=2) + "\n", encoding="utf-8")
+
+
+def _remove_codex_managed_block(path: Path, context_dir: Path) -> None:
+    if not path.exists():
+        return
+    text = path.read_text(encoding="utf-8")
+    start = text.find(_CODEX_MANAGED_BEGIN)
+    end = text.find(_CODEX_MANAGED_END)
+    if start < 0 or end < start:
+        return
+    end += len(_CODEX_MANAGED_END)
+    updated = (text[:start].rstrip() + "\n" + text[end:].lstrip()).strip()
+    if not updated:
+        path.unlink()
+        _rmdir_empty_parents(path, context_dir)
+        return
+    path.write_text(updated + "\n", encoding="utf-8")
+
+
+def _remove_legacy_mcp_context_files(context_dir: Path) -> None:
+    _remove_json_server(context_dir / ".mcp.json", "mcpServers", {"mcpServers": {}}, context_dir)
+    _remove_json_server(context_dir / ".cursor" / "mcp.json", "mcpServers", {"mcpServers": {}}, context_dir)
+    _remove_json_server(
+        context_dir / "opencode.json",
+        "mcp",
+        {"$schema": "https://opencode.ai/config.json", "mcp": {}},
+        context_dir,
+    )
+    _remove_codex_managed_block(context_dir / ".codex" / "config.toml", context_dir)
+
+
+def _tree_mtime(path: str) -> float:
+    """Max mtime across all entries under path (handles nested .claude/ dirs)."""
+    result = 0.0
+    for root, dirs, files in os.walk(path):
+        for name in dirs + files:
+            try:
+                result = max(result, os.stat(os.path.join(root, name)).st_mtime)
+            except OSError:
+                pass
+    return result
+
+
+def _rsync() -> bool:
+    result = subprocess.run(
+        ["rsync", "-a", "--delete", f"{CONTEXT_DIR}/", SQUID_HOME],
+        capture_output=True,
+    )
+    if result.returncode != 0:
+        log.warning("context sync failed: %s", result.stderr.decode().strip())
+        return False
+    return True
+
+
+def sync_now() -> None:
+    """Full blocking sync at daemon startup. Creates SQUID_HOME if needed."""
+    global _last_sync_mtime
+    os.makedirs(SQUID_HOME, exist_ok=True)
+    _seed_context_if_empty()
+    _remove_legacy_mcp_context_files(Path(CONTEXT_DIR))
+    if _rsync():
+        _last_sync_mtime = _tree_mtime(CONTEXT_DIR)
+        log.info("context synced → %s", SQUID_HOME)
+
+
+async def maybe_sync() -> None:
+    """Async stat-check before each prompt. No-op when nothing changed."""
+    global _last_sync_mtime
+    loop = asyncio.get_event_loop()
+    current = await loop.run_in_executor(None, _tree_mtime, CONTEXT_DIR)
+    if current <= _last_sync_mtime:
+        return
+    log.info("context changed, resyncing → %s", SQUID_HOME)
+    proc = await asyncio.create_subprocess_exec(
+        "rsync", "-a", "--delete", f"{CONTEXT_DIR}/", SQUID_HOME,
+        stdout=asyncio.subprocess.DEVNULL,
+        stderr=asyncio.subprocess.PIPE,
+    )
+    _, stderr = await proc.communicate()
+    if proc.returncode != 0:
+        log.warning("context sync failed: %s", stderr.decode().strip())
+    else:
+        _last_sync_mtime = current

agent/creds.py

@@ -0,0 +1,130 @@
+"""
+creds.py — Store and retrieve service credentials.
+Saved to ~/.squid/squid-creds.json alongside ~/.squid/squid.db and
+~/.squid/squid.yaml.
+"""
+
+import json
+from pathlib import Path
+from typing import Optional
+
+_CREDS_PATH = Path.home() / ".squid" / "squid-creds.json"
+_CODEX_AUTH_PATH = Path.home() / ".codex" / "auth.json"
+
+
+def load() -> dict:
+    try:
+        return json.loads(_CREDS_PATH.read_text())
+    except (FileNotFoundError, json.JSONDecodeError):
+        return {}
+
+
+def _save(data: dict) -> None:
+    existing = load()
+    existing.update(data)
+    _CREDS_PATH.write_text(json.dumps(existing, indent=2))
+
+
+def save(org_id: str, session_key: str) -> None:
+    _save({"claude_org_id": org_id, "claude_session_key": session_key})
+
+
+def save_codex(token: str) -> None:
+    _save({"codex_token": token})
+
+
+def get_org_id() -> Optional[str]:
+    d = load()
+    return d.get("claude_org_id") or d.get("org_id")
+
+
+def get_session_key() -> Optional[str]:
+    d = load()
+    return d.get("claude_session_key") or d.get("session_key")
+
+
+def get_codex_token() -> Optional[str]:
+    return load().get("codex_token")
+
+
+def get_codex_cli_auth() -> dict:
+    try:
+        data = json.loads(_CODEX_AUTH_PATH.read_text())
+    except (FileNotFoundError, json.JSONDecodeError):
+        return {}
+    tokens = data.get("tokens")
+    return tokens if isinstance(tokens, dict) else {}
+
+
+def _extract_cookies(domain: str) -> dict:
+    """Read all cookies for a domain from Chrome then Safari."""
+    import browser_cookie3
+    errors = []
+    for loader, name in [(browser_cookie3.chrome, "Chrome"), (browser_cookie3.safari, "Safari")]:
+        try:
+            jar = loader(domain_name=domain)
+            cookies = {c.name: c.value for c in jar}
+            if cookies:
+                return cookies
+        except PermissionError:
+            errors.append(
+                f"{name}: permission denied — grant Full Disk Access to Terminal in "
+                f"System Settings → Privacy & Security → Full Disk Access"
+            )
+        except Exception as e:
+            errors.append(f"{name}: {e}")
+    raise RuntimeError(" | ".join(errors) if errors else
+                       f"No cookies found for {domain} in Chrome or Safari. Make sure you are logged in.")
+
+
+def read_chrome_claude_creds() -> dict:
+    """Read sessionKey and lastActiveOrg from Chrome or Safari cookie store (macOS only)."""
+    cookies = _extract_cookies("claude.ai")
+    result = {k: v for k, v in cookies.items() if k in ("sessionKey", "lastActiveOrg")}
+    if not result.get("sessionKey"):
+        raise RuntimeError("sessionKey not found in claude.ai cookies. Make sure you are logged in.")
+    return result
+
+
+def save_max_budget(gauge: str, amount: float) -> None:
+    data = load()
+    budgets = data.get("max_budgets") or {}
+    budgets[gauge] = amount
+    data["max_budgets"] = budgets
+    if gauge == "deepseek":
+        data.pop("deepseek_max_budget", None)  # superseded legacy flat key
+    _CREDS_PATH.write_text(json.dumps(data, indent=2))
+
+
+def get_max_budget(gauge: str) -> Optional[float]:
+    data = load()
+    budgets = data.get("max_budgets") or {}
+    if gauge in budgets:
+        return budgets[gauge]
+    if gauge == "deepseek":
+        return data.get("deepseek_max_budget")  # legacy flat key
+    return None
+
+
+def clear_max_budget(gauge: str) -> None:
+    data = load()
+    budgets = data.get("max_budgets") or {}
+    budgets.pop(gauge, None)
+    data["max_budgets"] = budgets
+    if gauge == "deepseek":
+        data.pop("deepseek_max_budget", None)
+    _CREDS_PATH.write_text(json.dumps(data, indent=2))
+
+
+def get_cursor_token() -> Optional[str]:
+    """Read Cursor access token from macOS Keychain (where cursor-agent stores it)."""
+    try:
+        import subprocess
+        result = subprocess.run(
+            ["security", "find-generic-password", "-s", "cursor-access-token", "-w"],
+            capture_output=True, text=True, timeout=5,
+        )
+        token = result.stdout.strip()
+        return token or None
+    except Exception:
+        return None