talkpipe-vault 0.0.1__py3-none-any.whl

talkpipe_vault/__init__.py

@@ -0,0 +1,8 @@
+"""TalkPipe Vault - AI-powered personal information assistant.
+
+This package provides TalkPipe Vault components and plugin initialization.
+"""
+
+__version__ = "0.1.0"
+
+__all__ = ["__version__"]

talkpipe_vault/apps/__init__.py

@@ -0,0 +1 @@
+"""TalkPipe Vault applications for searching and chatting with vault contents."""

talkpipe_vault/apps/access_control.py

@@ -0,0 +1,94 @@
+"""Optional filesystem fences for the web interface.
+
+Two environment variables restrict which filesystem paths the web routes
+accept. Both are unset by default (an empty or whitespace-only value counts
+as unset), which leaves every route unrestricted — the right default for a
+single-user desktop install. Containerized or shared deployments set them so
+the browser UI cannot create vaults in ephemeral container paths or browse
+the server's whole filesystem:
+
+- ``TALKPIPE_VAULT_ROOT`` — a single directory; vaults may only be created,
+  opened, or deleted inside it.
+- ``TALKPIPE_DOCUMENT_ROOTS`` — ``os.pathsep``-separated directories; the
+  folder picker and document indexing are confined to them.
+
+Paths are fully resolved (symlinks followed) before containment checks, so a
+symlink inside an allowed root that points outside of it is rejected.
+"""
+
+import os
+from pathlib import Path
+
+VAULT_ROOT_ENV = "TALKPIPE_VAULT_ROOT"
+DOCUMENT_ROOTS_ENV = "TALKPIPE_DOCUMENT_ROOTS"
+
+
+def vault_root() -> Path | None:
+    """The directory vaults are confined to, or None when unrestricted."""
+    raw = os.environ.get(VAULT_ROOT_ENV, "").strip()
+    if not raw:
+        return None
+    return Path(raw).expanduser().resolve()
+
+
+def document_roots() -> list[Path]:
+    """Directories browsing/indexing are confined to; empty when unrestricted."""
+    raw = os.environ.get(DOCUMENT_ROOTS_ENV, "")
+    roots: list[Path] = []
+    for part in raw.split(os.pathsep):
+        part = part.strip()
+        if not part:
+            continue
+        resolved = Path(part).expanduser().resolve()
+        if resolved not in roots:
+            roots.append(resolved)
+    return roots
+
+
+def browse_roots() -> list[Path]:
+    """Union of vault and document roots for the folder picker.
+
+    The picker chooses both vault locations and document folders, so it may
+    see every configured root. Order is vault root first, then document
+    roots; empty means browsing is unrestricted.
+    """
+    roots: list[Path] = []
+    root = vault_root()
+    if root is not None:
+        roots.append(root)
+    for doc_root in document_roots():
+        if doc_root not in roots:
+            roots.append(doc_root)
+    return roots
+
+
+def is_allowed(path: str | Path, roots: list[Path]) -> bool:
+    """True when the fully-resolved path lies inside one of the roots.
+
+    An empty roots list means unrestricted, so everything is allowed.
+    """
+    if not roots:
+        return True
+    resolved = Path(path).expanduser().resolve()
+    return any(resolved.is_relative_to(root) for root in roots)
+
+
+def describe(roots: list[Path]) -> str:
+    """Human-readable list of allowed roots for error messages."""
+    return ", ".join(str(root) for root in roots)
+
+
+def startup_errors() -> list[str]:
+    """Configuration problems that should fail startup loudly.
+
+    A configured root that does not exist would otherwise lock the user out
+    of every path with no hint about why.
+    """
+    errors: list[str] = []
+    root = vault_root()
+    if root is not None and not root.is_dir():
+        errors.append(f"{VAULT_ROOT_ENV} points to {root}, which is not a directory.")
+    for doc_root in document_roots():
+        if not doc_root.is_dir():
+            errors.append(f"{DOCUMENT_ROOTS_ENV} entry {doc_root} is not a directory.")
+    return errors

talkpipe_vault/apps/credentials.py

@@ -0,0 +1,196 @@
+"""Persistent, vault-scoped provider credentials.
+
+Secrets and connection settings a user enters on the Settings page (API keys,
+the OpenAI base URL, the Ollama server URL) are stored in ``credentials.json``
+under the vault home (``$TALKPIPE_VAULT_HOME``) with owner-only permissions,
+and applied into the *process* environment at startup and whenever they change.
+
+Applying to ``os.environ`` — rather than the user's shell or ``~/.talkpipe.toml``
+— is what scopes these to the vault app: the OpenAI and Anthropic SDKs read
+their key and base URL directly from the environment, and TalkPipe reads the
+Ollama server URL from its own config (which we refresh from the same env var).
+Nothing is written outside the vault home, so other TalkPipe usage on the
+machine is unaffected.
+
+Precedence: a stored value overrides a pre-existing environment variable, so
+what a user types in the UI wins. We only ever unset variables we set
+ourselves, so a deployment that provides credentials purely through the
+environment (e.g. the container ``.env``) keeps working as long as the user
+leaves the corresponding field blank.
+"""
+
+import json
+import logging
+import os
+from dataclasses import dataclass
+from pathlib import Path
+
+from talkpipe.util.config import reset_config
+
+from talkpipe_vault.apps import user_settings
+
+logger = logging.getLogger(__name__)
+
+CREDENTIALS_FILENAME = "credentials.json"
+
+
+@dataclass(frozen=True)
+class _Field:
+    """A managed credential: its storage key, target env var, and metadata."""
+
+    key: str
+    env_var: str
+    secret: bool
+    label: str
+
+
+# Order here is the order rendered on the Settings page.
+FIELDS: tuple[_Field, ...] = (
+    _Field("openai_api_key", "OPENAI_API_KEY", True, "OpenAI API key"),
+    _Field("openai_base_url", "OPENAI_BASE_URL", False, "OpenAI base URL"),
+    _Field("anthropic_api_key", "ANTHROPIC_API_KEY", True, "Anthropic API key"),
+    _Field(
+        "ollama_server_url", "TALKPIPE_OLLAMA_SERVER_URL", False, "Ollama server URL"
+    ),
+)
+
+_FIELDS_BY_KEY = {field.key: field for field in FIELDS}
+
+# Env vars we set from the stored credentials, so we can safely unset only our
+# own when a value is cleared (never a variable the environment already had).
+_managed_env: set[str] = set()
+
+
+def _path() -> Path:
+    return user_settings.get_vault_home() / CREDENTIALS_FILENAME
+
+
+def store_path() -> Path:
+    """Absolute path to the credentials file (whether or not it exists yet)."""
+    return _path()
+
+
+def load() -> dict[str, str]:
+    """Load stored credentials, keeping only known non-empty string values."""
+    path = _path()
+    try:
+        with open(path, encoding="utf-8") as handle:
+            data = json.load(handle)
+        if not isinstance(data, dict):
+            raise ValueError("credentials root is not an object")
+    except FileNotFoundError:
+        return {}
+    except (OSError, ValueError) as exc:
+        logger.warning("Ignoring unreadable credentials file %s: %s", path, exc)
+        return {}
+
+    result: dict[str, str] = {}
+    for field in FIELDS:
+        value = data.get(field.key)
+        if isinstance(value, str) and value.strip():
+            result[field.key] = value.strip()
+    return result
+
+
+def _write(values: dict[str, str]) -> None:
+    """Persist credentials as JSON with owner-only (0600) permissions."""
+    path = _path()
+    path.parent.mkdir(parents=True, exist_ok=True)
+    tmp_path = path.with_suffix(".json.tmp")
+    # Create with 0600 from the start so the secret is never briefly world-readable.
+    fd = os.open(str(tmp_path), os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600)
+    with os.fdopen(fd, "w", encoding="utf-8") as handle:
+        json.dump(values, handle, indent=2)
+    os.replace(tmp_path, path)
+
+
+def set_values(changes: dict[str, str | None]) -> None:
+    """Merge credential changes, persist them, and apply to the environment.
+
+    ``changes`` maps field keys to values. A blank or ``None`` value clears
+    that field; fields absent from ``changes`` are left untouched. Unknown
+    keys are ignored.
+    """
+    data = load()
+    for key, value in changes.items():
+        if key not in _FIELDS_BY_KEY:
+            continue
+        cleaned = (value or "").strip()
+        if cleaned:
+            data[key] = cleaned
+        else:
+            data.pop(key, None)
+    _write(data)
+    apply()
+
+
+def apply() -> None:
+    """Apply stored credentials to the process environment.
+
+    Sets each configured value's env var, unsets any var we previously set but
+    is now cleared, and refreshes TalkPipe's cached config so a changed Ollama
+    URL takes effect. Leaves untouched any env var the vault never set.
+    """
+    global _managed_env
+    data = load()
+    now_managed: set[str] = set()
+    for field in FIELDS:
+        value = data.get(field.key)
+        if value:
+            os.environ[field.env_var] = value
+            now_managed.add(field.env_var)
+        elif field.env_var in _managed_env:
+            os.environ.pop(field.env_var, None)
+    _managed_env = now_managed
+    # TalkPipe caches config (including the Ollama URL) on first read; refresh
+    # so a newly applied TALKPIPE_OLLAMA_SERVER_URL is picked up.
+    reset_config()
+
+
+def source_for(env_var: str) -> str:
+    """Describe where a managed env var's current value comes from."""
+    if env_var in _managed_env:
+        return "Vault settings"
+    if os.environ.get(env_var):
+        return "environment"
+    return "unset"
+
+
+def _mask(secret: str) -> str:
+    """Mask a secret, revealing only the last few characters."""
+    if len(secret) <= 8:
+        return "••••"
+    return f"••••{secret[-4:]}"
+
+
+def describe() -> list[dict[str, object]]:
+    """Return per-field state for rendering the Settings form.
+
+    Secret values are never returned verbatim — only whether one is saved and
+    a masked hint. Non-secret values (URLs) are returned so the field can be
+    pre-filled.
+    """
+    data = load()
+    rows: list[dict[str, object]] = []
+    for field in FIELDS:
+        value = data.get(field.key, "")
+        # A non-secret value may be active from the environment (e.g. a
+        # container's TALKPIPE_OLLAMA_SERVER_URL) without being stored here.
+        # Surface it so the field isn't misleadingly blank. Secrets are never
+        # revealed, so we only report whether one is active, not its value.
+        active = "" if field.secret else os.environ.get(field.env_var, "")
+        rows.append(
+            {
+                "key": field.key,
+                "label": field.label,
+                "secret": field.secret,
+                "env_var": field.env_var,
+                "present": bool(value),
+                "masked": _mask(value) if value else "",
+                # Only non-secret values are safe to send back to the browser.
+                "value": "" if field.secret else value,
+                "active": active,
+                "source": source_for(field.env_var),
+            }
+        )
+    return rows