create-workframe 0.1.18 → 0.1.21

package/workframe-api/test_provider_bindings.py

@@ -3,13 +3,40 @@
 from __future__ import annotations
 
 import sys
+import time
 from pathlib import Path
+from types import SimpleNamespace
 
 sys.path.insert(0, str(Path(__file__).resolve().parent))
 
 import provider_bindings  # noqa: E402
 
 
+class _ProviderServerStub:
+    PROVIDER_CONNECT_CATALOG = (
+        {
+            "id": "openrouter",
+            "label": "OpenRouter",
+            "category": "llm",
+            "connect_mode": "api_key",
+            "env_var": "OPENROUTER_API_KEY",
+            "description": "router",
+        },
+    )
+
+    def __init__(self, mode: str) -> None:
+        self.mode = mode
+
+    def _workspace_credential_mode(self, _conn, _workspace_id: str) -> str:
+        return self.mode
+
+    def _credential_secret(self, binding: dict, _user_id: str) -> str:
+        return "secret" if binding else ""
+
+    def _user_hermes_home(self, _user_id: str) -> Path:
+        return Path("/profiles/user")
+
+
 def test_hermes_oauth_auth_keys() -> None:
     keys = provider_bindings._hermes_oauth_auth_keys("openai-codex")
     assert "openai-codex" in keys
@@ -50,7 +77,93 @@ def test_device_oauth_error_from_log() -> None:
         "Wait a minute and run the login again."
     )
     msg = provider_bindings._device_oauth_error_from_log(text)
-    assert msg and "429" in msg
+    assert msg == "OpenAI is rate-limiting Codex login requests (HTTP 429). Wait a minute and try again."
+
+
+def test_reusable_device_oauth_session() -> None:
+    provider_bindings._oauth_device_sessions.clear()
+    provider_bindings._oauth_device_sessions.update(
+        {
+            "old-error": {
+                "user_id": "user-1",
+                "provider_id": "openai-codex",
+                "status": "error",
+                "started_at": time.time(),
+            },
+            "live": {
+                "user_id": "user-1",
+                "provider_id": "openai-codex",
+                "status": "pending",
+                "started_at": time.time(),
+            },
+        }
+    )
+    reusable = provider_bindings._reusable_device_oauth_session("user-1", "openai-codex")
+    assert reusable and reusable[0] == "live"
+    assert provider_bindings._reusable_device_oauth_session("other", "openai-codex") is None
+    provider_bindings._oauth_device_sessions.clear()
+
+
+def test_finalize_device_oauth_invalidates_model_picker_before_bootstrap(monkeypatch) -> None:
+    calls: list[tuple[str, str]] = []
+    server = SimpleNamespace(
+        _invalidate_user_llm_picker_cache=lambda user_id: calls.append(("invalidate", user_id)),
+        _bootstrap_model_after_llm_connect=lambda user_id, _workspace_id, provider_id: calls.append(
+            ("bootstrap", f"{user_id}:{provider_id}")
+        ),
+    )
+    monkeypatch.setattr(provider_bindings, "_srv", lambda: server)
+    monkeypatch.setattr(
+        provider_bindings,
+        "_sync_user_oauth_provider_to_runtime_profiles",
+        lambda user_id, auth_id: calls.append(("sync", f"{user_id}:{auth_id}")),
+    )
+
+    provider_bindings._finalize_hermes_device_oauth(
+        "user-1",
+        "openai-codex",
+        {"hermes_auth_id": "openai-codex"},
+    )
+
+    assert calls == [
+        ("sync", "user-1:openai-codex"),
+        ("invalidate", "user-1"),
+        ("bootstrap", "user-1:openai-codex"),
+    ]
+
+
+def test_workspace_provider_scope_uses_shared_binding(monkeypatch) -> None:
+    monkeypatch.setattr(provider_bindings, "_srv", lambda: _ProviderServerStub("workspace"))
+    monkeypatch.setattr(provider_bindings, "_user_provider_bindings", lambda _uid: {})
+    monkeypatch.setattr(
+        provider_bindings,
+        "_workspace_provider_bindings",
+        lambda _wid: {"openrouter": {"id": "shared-1", "credential_ref": "vault:shared"}},
+    )
+    monkeypatch.setattr(provider_bindings, "_user_provider_connected", lambda *_args: False)
+
+    result = provider_bindings.list_user_providers("user-1", "workspace-1", "workspace")
+    row = result["providers"][0]
+    assert result["credential_scope"] == "workspace"
+    assert row["connected"] is True
+    assert row["source"] == "workspace"
+    assert row["credential_id"] == "shared-1"
+
+
+def test_byok_effective_scope_does_not_leak_shared_binding(monkeypatch) -> None:
+    monkeypatch.setattr(provider_bindings, "_srv", lambda: _ProviderServerStub("byok"))
+    monkeypatch.setattr(provider_bindings, "_user_provider_bindings", lambda _uid: {})
+    monkeypatch.setattr(
+        provider_bindings,
+        "_workspace_provider_bindings",
+        lambda _wid: {"openrouter": {"id": "shared-1", "credential_ref": "vault:shared"}},
+    )
+    monkeypatch.setattr(provider_bindings, "_user_provider_connected", lambda *_args: False)
+
+    row = provider_bindings.list_user_providers("user-1", "workspace-1", "effective")["providers"][0]
+    assert row["connected"] is False
+    assert row["source"] is None
+    assert row["credential_id"] is None
 
 
 if __name__ == "__main__":
@@ -59,4 +172,5 @@ if __name__ == "__main__":
     test_merge_oauth_auth_into_profile()
     test_parse_device_oauth_log()
     test_device_oauth_error_from_log()
+    test_reusable_device_oauth_session()
     print("test_provider_bindings: ok")

package/workframe-api/test_provider_model_catalog.py

@@ -0,0 +1,27 @@
+"""Pure model catalog parsing/cache helpers."""
+
+from __future__ import annotations
+
+import provider_model_catalog
+
+
+def test_oauth_access_token_provider_layout() -> None:
+    auth = {"providers": {"openai-codex": {"tokens": {"access_token": "live-token"}}}}
+    assert provider_model_catalog.oauth_access_token(auth, "openai-codex") == "live-token"
+
+
+def test_oauth_access_token_pool_layout() -> None:
+    auth = {"credential_pool": {"openai-codex": [{"accessToken": "pool-token"}]}}
+    assert provider_model_catalog.oauth_access_token(auth, "openai-codex") == "pool-token"
+
+
+def test_discover_without_credential_does_not_call_network() -> None:
+    rows, status = provider_model_catalog.discover("openrouter", "")
+    assert rows == []
+    assert status["status"] == "unauthenticated"
+
+
+def test_unknown_provider_preserves_custom_model_escape_hatch() -> None:
+    rows, status = provider_model_catalog.discover("nous", "oauth")
+    assert rows == []
+    assert status["status"] == "unsupported"

package/workframe-api/test_provider_model_surface.py

@@ -11,8 +11,8 @@ import server  # noqa: E402
 
 codex_rows = server._model_catalog_rows_for_provider("codex")
 codex_models = {row["model"] for row in codex_rows}
-assert "gpt-5.4-medium" in codex_models, codex_models
 assert "gpt-5.4-mini" in codex_models, codex_models
+assert "gpt-5.4-medium" not in codex_models, codex_models
 assert all("gemini" not in m for m in codex_models)
 
 assert server._resolve_billing_provider_for_model("gpt-5.4-mini", {"codex"}) == "codex"
@@ -23,7 +23,7 @@ assert server._resolve_billing_provider_for_model(
 
 stack = server._suggestions_for_connected_llm_providers({"codex", "openrouter"})
 models = {row["model"] for row in stack}
-assert "gpt-5.4-medium" in models
+assert "gpt-5.4-mini" in models
 assert any(m.startswith("google/") for m in models)
 
 assert server._billing_provider_id_from_hermes_config("openai-codex") == "codex"

package/workframe-api/test_runtime_lease_lifecycle.py

@@ -0,0 +1,93 @@
+"""Regression: LLM broker credentials are runtime-scoped, not chat-turn scoped."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import credential_vault
+import turn_credentials
+import turn_overlay
+
+
+class _ServerStub:
+    def __init__(self, root: Path) -> None:
+        self.root = root
+        self.restarts = 0
+
+    def resolve_hermes_profile(self, profile: str) -> str:
+        return profile
+
+    def _read_model_from_config(self, _profile: str) -> tuple[str, str]:
+        return "custom", "openrouter/auto"
+
+    def _read_env_map(self, path: Path) -> dict[str, str]:
+        values: dict[str, str] = {}
+        if path.is_file():
+            for line in path.read_text(encoding="utf-8").splitlines():
+                key, sep, value = line.partition("=")
+                if sep:
+                    values[key] = value
+        return values
+
+    def _profile_dir(self, _profile: str) -> Path:
+        path = self.root / "profile"
+        path.mkdir(parents=True, exist_ok=True)
+        return path
+
+    def _read_model_block(self, _profile: str) -> dict[str, str]:
+        path = self._profile_dir(_profile) / "model-key"
+        return {"api_key": path.read_text(encoding="utf-8") if path.is_file() else ""}
+
+    def _provider_env_var(self, _provider: str) -> str:
+        return "OPENROUTER_API_KEY"
+
+    def _is_runtime_profile_slug(self, _profile: str) -> bool:
+        return True
+
+    def _oauth_llm_provider_spec(self, _provider: str):
+        return None
+
+    def _upsert_env_secret(self, path: Path, key: str, value: str) -> None:
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(f"{key}={value}\n", encoding="utf-8")
+
+
+def test_runtime_llm_lease_survives_chat_turn_cleanup(tmp_path, monkeypatch) -> None:
+    db_path = tmp_path / "workframe.db"
+    monkeypatch.setattr(turn_credentials, "WORKFRAME_DB", db_path)
+    turn_credentials._SCHEMA_READY.clear()
+    monkeypatch.setattr(credential_vault, "DATA_DIR", tmp_path)
+    monkeypatch.setattr(credential_vault, "VAULT_DB", tmp_path / "credential_vault.db")
+    credential_vault._SCHEMA_READY.clear()
+    stub = _ServerStub(tmp_path)
+    monkeypatch.setattr(turn_overlay, "_srv", lambda: stub)
+    monkeypatch.setattr(
+        turn_overlay,
+        "_require_runtime_owner_provider",
+        lambda *_args, **_kwargs: {"credential_binding_id": "binding-1"},
+    )
+    monkeypatch.setattr(turn_overlay, "_ensure_profile_llm_proxy", lambda *_args: None)
+
+    def _sync(profile: str, token: str, *, wait_healthy: bool = False) -> None:
+        (stub._profile_dir(profile) / "model-key").write_text(token, encoding="utf-8")
+        if wait_healthy:
+            stub.restarts += 1
+
+    monkeypatch.setattr(turn_overlay, "_sync_profile_model_api_key", _sync)
+    monkeypatch.setattr(turn_overlay, "_user_action_env_specs", lambda: [])
+
+    token_a = turn_overlay._apply_turn_credential_lease(
+        "u-user-agent", "user-1", "workspace-1", "openrouter", "turn-a",
+    )
+    token_b = turn_overlay._apply_turn_credential_lease(
+        "u-user-agent", "user-1", "workspace-1", "openrouter", "turn-b",
+    )
+
+    assert token_a == token_b
+    assert stub.restarts == 1
+    lease = turn_credentials.validate_lease(token_a)
+    assert lease and lease["run_id"].startswith("runtime-llm:")
+
+    turn_overlay._revoke_turn_credential_lease("turn-b", "u-user-agent")
+    assert turn_credentials.validate_lease(token_a)
+    assert stub.restarts == 1

package/workframe-api/test_server_reexports.py

@@ -32,6 +32,8 @@ _REQUIRED = (
     "_session_info",
     "chat_messages",
     "chat_bootstrap",
+    "files_archive",
+    "files_delete",
     "_gateway_container_exec",
     "_gateway_container_exec_detached",
     "_docker_exec",

package/workframe-api/test_user_llm_prefs.py

@@ -95,5 +95,32 @@ def test_user_llm_prefs_infers_primary_from_fallback_chain(llm_prefs_db) -> None
     assert chain[0]["model"] == "google/gemini-2.5-flash"
 
 
+def test_linked_account_save_preserves_llm_preferences(
+    llm_prefs_db, monkeypatch: pytest.MonkeyPatch,
+) -> None:  # noqa: ARG001
+    import user_prefs  # noqa: WPS433
+
+    stored = json.dumps({
+        "discord": "old-discord",
+        "llm_primary": "google/gemini-2.5-flash",
+        "llm_fallback_chain": json.dumps([
+            {"provider": "openrouter", "model": "meta-llama/llama-3.3-70b-instruct:free"},
+        ]),
+    })
+    user_id = _insert_user(email="merge@test.local", display_name="Merge", platform_ids=stored)
+    monkeypatch.setattr(user_prefs._zk, "update_profile", lambda *_args, **_kwargs: {})
+    monkeypatch.setattr(user_prefs._zk, "get_profile", lambda *_args, **_kwargs: {})
+    monkeypatch.setattr(user_prefs, "sync_workframe_user_profile", lambda *_args, **_kwargs: None)
+    monkeypatch.setattr(server, "_get_user_workspaces", lambda _user: [])
+
+    user_prefs.apply_me_profile_updates(user_id, {"platform_ids": {"discord": "new-discord"}})
+
+    user = user_prefs.get_workframe_user(user_id)
+    assert user is not None
+    assert user["platform_ids"]["discord"] == "new-discord"
+    assert user["platform_ids"]["llm_primary"] == "google/gemini-2.5-flash"
+    assert "llama-3.3-70b" in user["platform_ids"]["llm_fallback_chain"]
+
+
 if __name__ == "__main__":
     raise SystemExit(pytest.main([__file__, "-q"]))

package/workframe-api/test_user_theme_prefs.py

@@ -0,0 +1,65 @@
+"""Personal appearance preference persists in the authenticated profile."""
+
+from __future__ import annotations
+
+import sqlite3
+import sys
+import tempfile
+from datetime import datetime, timezone
+from pathlib import Path
+
+import pytest
+
+API_DIR = Path(__file__).resolve().parent
+if str(API_DIR) not in sys.path:
+    sys.path.insert(0, str(API_DIR))
+
+import zk_auth  # noqa: E402
+
+
+def test_theme_profile_round_trip_and_legacy_migration(monkeypatch: pytest.MonkeyPatch) -> None:
+    with tempfile.TemporaryDirectory(prefix="wf-theme-prefs-") as tmp:
+        data_dir = Path(tmp)
+        db_path = data_dir / "zk_auth.db"
+        data_dir.mkdir(parents=True, exist_ok=True)
+
+        legacy = sqlite3.connect(db_path)
+        legacy.executescript(
+            """
+            CREATE TABLE users (
+                id TEXT PRIMARY KEY,
+                status TEXT NOT NULL,
+                created_at TEXT NOT NULL,
+                updated_at TEXT NOT NULL
+            );
+            CREATE TABLE profiles (
+                user_id TEXT PRIMARY KEY,
+                display_name TEXT,
+                avatar_url TEXT,
+                tagline TEXT,
+                bio TEXT,
+                created_at TEXT NOT NULL,
+                updated_at TEXT NOT NULL
+            );
+            """
+        )
+        now = datetime.now(timezone.utc).isoformat()
+        legacy.execute("INSERT INTO users VALUES (?, 'active', ?, ?)", ("user-theme", now, now))
+        legacy.commit()
+        legacy.close()
+
+        monkeypatch.setenv("WORKFRAME_API_DATA_DIR", str(data_dir))
+        profile = zk_auth.update_profile("user-theme", {"theme": "blueprint"})
+
+        assert profile is not None
+        assert profile["theme"] == "blueprint"
+        conn = zk_auth._zk_db()
+        try:
+            columns = {row[1] for row in conn.execute("PRAGMA table_info(profiles)").fetchall()}
+        finally:
+            conn.close()
+        assert "theme" in columns
+
+
+if __name__ == "__main__":
+    raise SystemExit(pytest.main([__file__, "-q"]))

package/workframe-api/test_workspace_file_actions.py

@@ -0,0 +1,119 @@
+from __future__ import annotations
+
+import io
+import sys
+import zipfile
+from pathlib import Path
+
+import pytest
+
+API_DIR = Path(__file__).resolve().parent
+if str(API_DIR) not in sys.path:
+    sys.path.insert(0, str(API_DIR))
+
+import route_registry  # noqa: E402
+import server  # noqa: E402
+import workspace_files  # noqa: E402
+
+
+def _workspace(monkeypatch: pytest.MonkeyPatch, tmp_path: Path) -> Path:
+    root = tmp_path / "workspace"
+    root.mkdir()
+    monkeypatch.setattr(server, "WORKSPACE", root)
+    return root
+
+
+def test_files_archive_preserves_relative_paths(monkeypatch: pytest.MonkeyPatch, tmp_path: Path) -> None:
+    root = _workspace(monkeypatch, tmp_path)
+    (root / "docs").mkdir()
+    (root / "docs" / "notes.txt").write_text("hello", encoding="utf-8")
+    (root / "image.bin").write_bytes(b"\x00\x01")
+
+    payload = workspace_files.files_archive(["docs/notes.txt", "image.bin", "docs/notes.txt"])
+    with zipfile.ZipFile(io.BytesIO(payload)) as archive:
+        assert archive.namelist() == ["docs/notes.txt", "image.bin"]
+        assert archive.read("docs/notes.txt") == b"hello"
+        assert archive.read("image.bin") == b"\x00\x01"
+
+
+def test_files_archive_expands_folders_and_deduplicates_descendants(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    root = _workspace(monkeypatch, tmp_path)
+    (root / "assets" / "nested").mkdir(parents=True)
+    (root / "assets" / "one.txt").write_text("one", encoding="utf-8")
+    (root / "assets" / "nested" / "two.txt").write_text("two", encoding="utf-8")
+    (root / "assets" / "nested" / ".env").write_text("SECRET=value", encoding="utf-8")
+
+    payload = workspace_files.files_archive(["assets", "assets/nested/two.txt"])
+
+    with zipfile.ZipFile(io.BytesIO(payload)) as archive:
+        assert archive.namelist() == ["assets/nested/two.txt", "assets/one.txt"]
+        assert archive.read("assets/nested/two.txt") == b"two"
+        assert ".env" not in "\n".join(archive.namelist())
+
+
+def test_files_archive_folder_respects_resolved_file_limit(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    root = _workspace(monkeypatch, tmp_path)
+    (root / "assets").mkdir()
+    (root / "assets" / "one.txt").write_text("one", encoding="utf-8")
+    (root / "assets" / "two.txt").write_text("two", encoding="utf-8")
+    monkeypatch.setattr(workspace_files, "MAX_FILE_ACTION_COUNT", 1)
+
+    with pytest.raises(ValueError, match="select at most 1 files"):
+        workspace_files.files_archive(["assets"])
+
+
+def test_files_archive_rejects_protected_and_oversized_files(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    root = _workspace(monkeypatch, tmp_path)
+    (root / ".env").write_text("SECRET=value", encoding="utf-8")
+    (root / "large.bin").write_bytes(b"12")
+
+    with pytest.raises(PermissionError, match="protected_env_file"):
+        workspace_files.files_archive([".env"])
+
+    monkeypatch.setattr(workspace_files, "MAX_ARCHIVE_BYTES", 1)
+    with pytest.raises(ValueError, match="100 MB download limit"):
+        workspace_files.files_archive(["large.bin"])
+
+
+def test_files_delete_preflights_complete_batch(monkeypatch: pytest.MonkeyPatch, tmp_path: Path) -> None:
+    root = _workspace(monkeypatch, tmp_path)
+    keep = root / "keep.txt"
+    keep.write_text("keep", encoding="utf-8")
+
+    with pytest.raises(ValueError, match="file not found"):
+        workspace_files.files_delete(["keep.txt", "missing.txt"])
+
+    assert keep.is_file()
+
+
+def test_files_delete_removes_selected_files_and_routes_require_session(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    root = _workspace(monkeypatch, tmp_path)
+    first = root / "first.txt"
+    second = root / "nested" / "second.txt"
+    second.parent.mkdir()
+    first.write_text("first", encoding="utf-8")
+    second.write_text("second", encoding="utf-8")
+
+    result = workspace_files.files_delete(["first.txt", "nested/second.txt"])
+
+    assert result == {
+        "ok": True,
+        "deleted": ["first.txt", "nested/second.txt"],
+        "count": 2,
+    }
+    assert not first.exists()
+    assert not second.exists()
+    assert route_registry.resolve_auth_level("POST", "/api/files/archive") == route_registry.AuthLevel.SESSION
+    assert route_registry.resolve_auth_level("POST", "/api/files/delete") == route_registry.AuthLevel.SESSION

package/workframe-api/turn_credentials.py

@@ -17,6 +17,11 @@ DATA_DIR = Path(os.environ.get("WORKFRAME_API_DATA_DIR", "/app/data"))
 WORKFRAME_DB = DATA_DIR / "workframe.db"
 LEASE_PREFIX = "wf_rt_"
 DEFAULT_TTL = int(os.environ.get("WORKFRAME_TURN_LEASE_TTL", "900"))
+# LLM authorization belongs to a user-specific runtime profile, not to an
+# individual chat turn.  Keep that opaque broker credential long-lived and
+# explicitly revocable; rotating it on every message forces Hermes to restart
+# its gateway and can drop the in-flight response.
+RUNTIME_TTL = int(os.environ.get("WORKFRAME_RUNTIME_LEASE_TTL", "2592000"))
 
 
 def _connect() -> sqlite3.Connection:
@@ -220,6 +225,42 @@ def revoke_lease(run_id: str) -> None:
         conn.close()
 
 
+def revoke_matching_leases(
+    *,
+    payer_user_id: str = "",
+    workspace_id: str = "",
+    provider: str = "",
+    credential_binding_id: str = "",
+) -> int:
+    """Revoke active broker credentials after an ownership/binding change."""
+    clauses = ["revoked_at IS NULL"]
+    params: list[str] = []
+    for column, value in (
+        ("payer_user_id", payer_user_id),
+        ("workspace_id", workspace_id),
+        ("provider", str(provider or "").strip().lower()),
+        ("credential_binding_id", credential_binding_id),
+    ):
+        normalized = str(value or "").strip()
+        if normalized:
+            clauses.append(f"{column} = ?")
+            params.append(normalized)
+    if len(clauses) == 1:
+        return 0
+    ensure_schema()
+    now = datetime.now(timezone.utc).isoformat()
+    conn = _connect()
+    try:
+        cur = conn.execute(
+            f"UPDATE turn_credential_leases SET revoked_at = ? WHERE {' AND '.join(clauses)}",
+            (now, *params),
+        )
+        conn.commit()
+        return int(cur.rowcount or 0)
+    finally:
+        conn.close()
+
+
 def resolve_lease_secret(lease: dict[str, Any], resolve_secret_fn) -> tuple[str, str]:
     """resolve_secret_fn(user_id, workspace_id, provider, binding_id) -> (env_var, secret)."""
     binding_id = str(lease.get("credential_binding_id") or "").strip()