flowent 0.0.0 → 0.0.4

package/backend/tests/unit/test_access.py

@@ -0,0 +1,45 @@
+from loguru import logger
+
+from flowent.access import (
+    ensure_access_bootstrap,
+    is_access_configured,
+    set_access_code,
+)
+from flowent.settings import Settings
+
+
+def test_ensure_access_bootstrap_generates_and_logs_access_code() -> None:
+    settings = Settings()
+    messages: list[str] = []
+    sink_id = logger.add(messages.append, format="{message}")
+
+    try:
+        generated_code = ensure_access_bootstrap(settings)
+    finally:
+        logger.remove(sink_id)
+
+    assert generated_code
+    assert settings.access.code == generated_code
+    assert is_access_configured(settings.access)
+    assert any(
+        f"Flowent admin access code: {generated_code}" in message
+        for message in messages
+    )
+
+
+def test_ensure_access_bootstrap_logs_existing_persisted_access_code() -> None:
+    settings = Settings()
+    set_access_code(settings, "TEST-ACCESS-CODE")
+    messages: list[str] = []
+    sink_id = logger.add(messages.append, format="{message}")
+
+    try:
+        generated_code = ensure_access_bootstrap(settings)
+    finally:
+        logger.remove(sink_id)
+
+    assert generated_code is None
+    assert settings.access.code == "TEST-ACCESS-CODE"
+    assert any(
+        "Flowent admin access code: TEST-ACCESS-CODE" in message for message in messages
+    )

package/backend/tests/unit/test_cli.py

@@ -0,0 +1,124 @@
+import os
+
+import pytest
+
+from flowent.access import is_access_configured, set_access_code, verify_access_code
+from flowent.cli import APP_DATA_DIR_ENV_VAR, main
+
+
+def test_access_refresh_command_generates_new_persisted_access_code(
+    monkeypatch, tmp_path, capsys
+):
+    import flowent.settings as settings_module
+
+    settings_file = tmp_path / "settings.json"
+    monkeypatch.setattr(settings_module, "_SETTINGS_FILE", settings_file)
+    monkeypatch.setattr(settings_module, "_cached_settings", None)
+
+    settings = settings_module.Settings()
+    set_access_code(settings, "OLD-ACCESS-CODE")
+    settings_module.save_settings(settings)
+    monkeypatch.setattr(settings_module, "_cached_settings", None)
+
+    main(["access", "refresh"])
+
+    output = capsys.readouterr().out.strip()
+    reloaded_settings = settings_module.load_settings()
+
+    assert output.startswith("Generated new access code: ")
+    next_code = output.removeprefix("Generated new access code: ").strip()
+    assert next_code
+    assert reloaded_settings.access.code == next_code
+    assert verify_access_code(reloaded_settings.access, next_code)
+    assert not verify_access_code(reloaded_settings.access, "OLD-ACCESS-CODE")
+
+
+def test_access_reset_command_clears_persisted_access_code(
+    monkeypatch, tmp_path, capsys
+):
+    import flowent.settings as settings_module
+
+    settings_file = tmp_path / "settings.json"
+    monkeypatch.setattr(settings_module, "_SETTINGS_FILE", settings_file)
+    monkeypatch.setattr(settings_module, "_cached_settings", None)
+
+    settings = settings_module.Settings()
+    set_access_code(settings, "TEST-ACCESS-CODE")
+    settings_module.save_settings(settings)
+    monkeypatch.setattr(settings_module, "_cached_settings", None)
+
+    main(["access", "reset"])
+
+    output = capsys.readouterr().out.strip()
+    reloaded_settings = settings_module.load_settings()
+
+    assert output == (
+        "Access configuration cleared. Restart Flowent to generate a new access code."
+    )
+    assert reloaded_settings.access.code == ""
+    assert not is_access_configured(reloaded_settings.access)
+
+
+def test_help_output_no_longer_lists_mcp_command(capsys):
+    with pytest.raises(SystemExit) as exc:
+        main(["--help"])
+
+    assert exc.value.code == 0
+    output = capsys.readouterr().out
+
+    assert "access" in output
+    assert "mcp" not in output
+
+
+def test_version_short_option_matches_version_output(capsys):
+    with pytest.raises(SystemExit) as exc:
+        main(["-v"])
+
+    assert exc.value.code == 0
+    assert capsys.readouterr().out.startswith("flowent ")
+
+
+def test_server_options_accept_npm_wrapper_aliases(monkeypatch):
+    called: dict[str, object] = {}
+
+    monkeypatch.setattr(
+        "uvicorn.run",
+        lambda app, *, host, port: called.update(
+            {"app": app, "host": host, "port": port}
+        ),
+    )
+
+    main(["--hostname", "127.0.0.1", "-p", "7000"])
+
+    assert called == {
+        "app": "flowent.main:app",
+        "host": "127.0.0.1",
+        "port": 7000,
+    }
+
+
+def test_removed_mcp_command_is_rejected(capsys):
+    with pytest.raises(SystemExit) as exc:
+        main(["mcp", "serve"])
+
+    assert exc.value.code == 2
+    error_output = capsys.readouterr().err
+
+    assert "invalid choice" in error_output
+    assert "'mcp'" in error_output
+
+
+def test_cli_sets_app_data_dir_env_before_dispatch(monkeypatch, tmp_path, capsys):
+    monkeypatch.delenv(APP_DATA_DIR_ENV_VAR, raising=False)
+    called: list[str] = []
+
+    monkeypatch.setattr(
+        "flowent.access.refresh_local_access",
+        lambda: called.append("refresh") or "Generated new access code: TEST",
+    )
+
+    main(["--app-data-dir", str(tmp_path), "access", "refresh"])
+
+    assert called == ["refresh"]
+    assert os.environ[APP_DATA_DIR_ENV_VAR] == str(tmp_path)
+    assert capsys.readouterr().out.strip() == "Generated new access code: TEST"

package/backend/tests/unit/test_graph_runtime.py

@@ -0,0 +1,72 @@
+from flowent.agent import Agent
+from flowent.graph_runtime import resolve_node_ref
+from flowent.models import NodeConfig, NodeType
+from flowent.registry import registry
+
+
+def setup_function():
+    registry.reset()
+
+
+def teardown_function():
+    registry.reset()
+
+
+def test_resolve_node_ref_matches_exact_uuid():
+    planner = Agent(
+        NodeConfig(node_type=NodeType.AGENT),
+        uuid="12345678-aaaa-bbbb-cccc-ddddeeeeffff",
+    )
+    registry.register(planner)
+
+    assert resolve_node_ref("12345678-aaaa-bbbb-cccc-ddddeeeeffff") is planner
+
+
+def test_resolve_node_ref_matches_exact_name():
+    planner = Agent(
+        NodeConfig(node_type=NodeType.AGENT, name="Planner"),
+        uuid="12345678-aaaa-bbbb-cccc-ddddeeeeffff",
+    )
+    registry.register(planner)
+
+    assert resolve_node_ref("Planner") is planner
+
+
+def test_resolve_node_ref_matches_short_uuid_prefix():
+    planner = Agent(
+        NodeConfig(node_type=NodeType.AGENT),
+        uuid="12345678-aaaa-bbbb-cccc-ddddeeeeffff",
+    )
+    reviewer = Agent(
+        NodeConfig(node_type=NodeType.AGENT),
+        uuid="87654321-aaaa-bbbb-cccc-ddddeeeeffff",
+    )
+    registry.register(planner)
+    registry.register(reviewer)
+
+    assert resolve_node_ref("12345678") is planner
+
+
+def test_resolve_node_ref_rejects_ambiguous_prefix():
+    planner = Agent(
+        NodeConfig(node_type=NodeType.AGENT),
+        uuid="1234aaaa-aaaa-bbbb-cccc-ddddeeeeffff",
+    )
+    reviewer = Agent(
+        NodeConfig(node_type=NodeType.AGENT),
+        uuid="1234bbbb-aaaa-bbbb-cccc-ddddeeeeffff",
+    )
+    registry.register(planner)
+    registry.register(reviewer)
+
+    assert resolve_node_ref("1234") is None
+
+
+def test_resolve_node_ref_rejects_too_short_prefix():
+    planner = Agent(
+        NodeConfig(node_type=NodeType.AGENT),
+        uuid="12345678-aaaa-bbbb-cccc-ddddeeeeffff",
+    )
+    registry.register(planner)
+
+    assert resolve_node_ref("123") is None

package/backend/tests/unit/test_network.py

@@ -0,0 +1,51 @@
+import socket
+import threading
+import time
+
+from flowent.network import create_http_session
+
+
+def _capture_raw_request() -> str:
+    captured: dict[str, str] = {}
+    ready = threading.Event()
+
+    def serve() -> None:
+        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as server:
+            server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+            server.bind(("127.0.0.1", 18084))
+            server.listen(1)
+            ready.set()
+            connection, _ = server.accept()
+            with connection:
+                payload = b""
+                connection.settimeout(2)
+                while b"\r\n\r\n" not in payload:
+                    chunk = connection.recv(4096)
+                    if not chunk:
+                        break
+                    payload += chunk
+                captured["request"] = payload.decode("latin1", errors="replace")
+                body = b"{}"
+                connection.sendall(
+                    b"HTTP/1.1 200 OK\r\n"
+                    b"Content-Type: application/json\r\n"
+                    b"Content-Length: 2\r\n"
+                    b"Connection: close\r\n\r\n" + body
+                )
+
+    server_thread = threading.Thread(target=serve, daemon=True)
+    server_thread.start()
+    ready.wait()
+    time.sleep(0.05)
+
+    with create_http_session(timeout=5) as client:
+        response = client.post("http://127.0.0.1:18084/v1/messages", json={"x": 1})
+    assert response.status_code == 200
+    return captured["request"]
+
+
+def test_create_http_session_does_not_send_upgrade_by_default():
+    request = _capture_raw_request()
+
+    assert "Upgrade: h2c" not in request
+    assert "Connection: Upgrade" not in request

package/backend/tests/unit/test_state_sqlite_storage.py

@@ -0,0 +1,93 @@
+import base64
+import sqlite3
+import time
+
+import flowent.settings as settings_module
+from flowent.image_assets import create_image_asset
+from flowent.mcp_service import MCPDiscoverySnapshot, mcp_service
+
+_ONE_PIXEL_PNG = base64.b64decode(
+    "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO+aF9sAAAAASUVORK5CYII="
+)
+
+
+def test_create_image_asset_persists_metadata_in_state_sqlite(monkeypatch, tmp_path):
+    settings_file = tmp_path / "settings.json"
+    settings_file.write_text("{}", encoding="utf-8")
+    monkeypatch.setattr(settings_module, "_SETTINGS_FILE", settings_file)
+    monkeypatch.setattr(settings_module, "_cached_settings", None)
+
+    asset = create_image_asset(
+        _ONE_PIXEL_PNG,
+        mime_type="image/png",
+        original_name="pixel.png",
+    )
+
+    assert asset.file_path == tmp_path / "assets" / "images" / asset.stored_name
+    assert asset.file_path.is_file()
+    connection = sqlite3.connect(tmp_path / "state.sqlite")
+    connection.row_factory = sqlite3.Row
+    try:
+        row = connection.execute(
+            """
+            SELECT stored_name, mime_type, width, height, original_name
+            FROM image_assets
+            WHERE id = ?
+            """,
+            (asset.id,),
+        ).fetchone()
+    finally:
+        connection.close()
+    assert row is not None
+    assert row["stored_name"] == asset.stored_name
+    assert row["mime_type"] == "image/png"
+    assert row["width"] == 1
+    assert row["height"] == 1
+    assert row["original_name"] == "pixel.png"
+
+
+def test_mcp_service_restores_persisted_snapshot_and_activity_after_runtime_clear(
+    monkeypatch,
+    tmp_path,
+):
+    settings_file = tmp_path / "settings.json"
+    settings_file.write_text("{}", encoding="utf-8")
+    monkeypatch.setattr(settings_module, "_SETTINGS_FILE", settings_file)
+    monkeypatch.setattr(settings_module, "_cached_settings", None)
+    mcp_service.reset()
+    now = time.time()
+
+    try:
+        mcp_service._set_snapshot(
+            MCPDiscoverySnapshot(
+                server_name="filesystem",
+                transport="stdio",
+                status="connected",
+                auth_status="unsupported",
+                last_refresh_result="success",
+            )
+        )
+        mcp_service._record_activity(
+            server_name="filesystem",
+            action="refresh",
+            actor_node_id=None,
+            tab_id=None,
+            started_at=now - 2.0,
+            ended_at=now,
+            result="success",
+            summary="Capabilities refreshed",
+        )
+
+        mcp_service.clear_runtime_state()
+
+        restored_snapshot = mcp_service._get_snapshot("filesystem")
+        restored_activities = mcp_service.list_activities(server_name="filesystem")
+
+        assert restored_snapshot is not None
+        assert restored_snapshot.status == "connected"
+        assert restored_snapshot.last_refresh_result == "success"
+        assert len(restored_activities) == 1
+        assert restored_activities[0].server_name == "filesystem"
+        assert restored_activities[0].summary == "Capabilities refreshed"
+    finally:
+        mcp_service.reset()

package/backend/tests/unit/test_workspace_store.py

@@ -0,0 +1,231 @@
+import json
+import sqlite3
+
+from flowent.settings import Settings
+from flowent.state_db import open_state_db
+from flowent.workspace_store import workspace_store
+
+
+def test_workspace_store_normalizes_relative_write_dirs_on_load(
+    monkeypatch,
+    tmp_path,
+):
+    import flowent.settings as settings_module
+
+    settings_file = tmp_path / "settings.json"
+    workspace_file = tmp_path / "workspace.json"
+    working_dir = tmp_path / "workspace-root"
+    working_dir.mkdir()
+    workspace_file.write_text(
+        json.dumps(
+            {
+                "tabs": [],
+                "nodes": [
+                    {
+                        "id": "node-1",
+                        "config": {
+                            "node_type": "agent",
+                            "role_name": "Worker",
+                            "tab_id": "tab-1",
+                            "name": "Worker",
+                            "tools": ["read"],
+                            "write_dirs": ["./out"],
+                            "allow_network": False,
+                        },
+                        "state": "idle",
+                        "todos": [],
+                        "history": [],
+                    }
+                ],
+                "edges": [],
+                "blueprints": [],
+            }
+        ),
+        encoding="utf-8",
+    )
+
+    monkeypatch.setattr(settings_module, "_SETTINGS_FILE", settings_file)
+    monkeypatch.setattr(
+        settings_module,
+        "get_settings",
+        lambda: Settings(working_dir=str(working_dir)),
+    )
+    workspace_store.reset_cache()
+
+    record = workspace_store.get_node_record("node-1")
+
+    assert record is not None
+    assert record.config.write_dirs == [str((working_dir / "out").resolve())]
+    connection = open_state_db(create=False)
+    assert connection is not None
+    try:
+        row = connection.execute(
+            "SELECT payload FROM nodes WHERE id = ?",
+            ("node-1",),
+        ).fetchone()
+    finally:
+        connection.close()
+    assert row is not None
+    persisted = json.loads(row["payload"])
+    assert persisted["config"]["write_dirs"] == [str((working_dir / "out").resolve())]
+    workspace_store.reset_cache()
+
+
+def test_workspace_store_prefers_legacy_workspace_data_when_state_db_is_still_empty(
+    monkeypatch,
+    tmp_path,
+):
+    import flowent.settings as settings_module
+
+    settings_file = tmp_path / "settings.json"
+    workspace_file = tmp_path / "workspace.json"
+    state_db_file = tmp_path / "state.sqlite"
+    settings_file.write_text("{}", encoding="utf-8")
+    workspace_file.write_text(
+        json.dumps(
+            {
+                "tabs": [],
+                "nodes": [
+                    {
+                        "id": "node-legacy",
+                        "config": {
+                            "node_type": "agent",
+                            "role_name": "Worker",
+                            "tab_id": "tab-1",
+                            "name": "Worker",
+                            "tools": ["read"],
+                            "write_dirs": [],
+                            "allow_network": False,
+                        },
+                        "state": "idle",
+                        "todos": [],
+                        "history": [],
+                    }
+                ],
+                "edges": [],
+                "blueprints": [],
+            }
+        ),
+        encoding="utf-8",
+    )
+    sqlite3.connect(state_db_file).close()
+
+    monkeypatch.setattr(settings_module, "_SETTINGS_FILE", settings_file)
+    monkeypatch.setattr(settings_module, "_cached_settings", None)
+    monkeypatch.setattr(
+        settings_module,
+        "get_settings",
+        lambda: Settings(working_dir=str(tmp_path)),
+    )
+    workspace_store.reset_cache()
+
+    record = workspace_store.get_node_record("node-legacy")
+
+    assert record is not None
+    assert record.id == "node-legacy"
+    workspace_store.reset_cache()
+
+
+def test_workspace_store_does_not_overwrite_state_db_with_legacy_workspace_data(
+    monkeypatch,
+    tmp_path,
+):
+    import flowent.settings as settings_module
+
+    settings_file = tmp_path / "settings.json"
+    workspace_file = tmp_path / "workspace.json"
+    settings_file.write_text("{}", encoding="utf-8")
+    workspace_file.write_text(
+        json.dumps(
+            {
+                "tabs": [],
+                "nodes": [
+                    {
+                        "id": "node-legacy",
+                        "config": {
+                            "node_type": "agent",
+                            "role_name": "Worker",
+                            "tab_id": "tab-1",
+                            "name": "Legacy",
+                            "tools": ["read"],
+                            "write_dirs": [],
+                            "allow_network": False,
+                        },
+                        "state": "idle",
+                        "todos": [],
+                        "history": [],
+                    }
+                ],
+                "edges": [],
+                "blueprints": [],
+            }
+        ),
+        encoding="utf-8",
+    )
+
+    monkeypatch.setattr(settings_module, "_SETTINGS_FILE", settings_file)
+    monkeypatch.setattr(settings_module, "_cached_settings", None)
+    monkeypatch.setattr(
+        settings_module,
+        "get_settings",
+        lambda: Settings(working_dir=str(tmp_path)),
+    )
+    connection = open_state_db(create=True)
+    assert connection is not None
+    try:
+        with connection:
+            connection.execute(
+                """
+                INSERT INTO nodes (id, payload, tab_id, node_type, updated_at)
+                VALUES (?, ?, ?, ?, ?)
+                """,
+                (
+                    "node-sqlite",
+                    json.dumps(
+                        {
+                            "id": "node-sqlite",
+                            "config": {
+                                "node_type": "agent",
+                                "role_name": "Worker",
+                                "tab_id": "tab-1",
+                                "name": "SQLite",
+                                "tools": ["read"],
+                                "write_dirs": [],
+                                "allow_network": False,
+                            },
+                            "state": "idle",
+                            "todos": [],
+                            "history": [],
+                        }
+                    ),
+                    "tab-1",
+                    "agent",
+                    1.0,
+                ),
+            )
+    finally:
+        connection.close()
+
+    workspace_store.reset_cache()
+
+    sqlite_record = workspace_store.get_node_record("node-sqlite")
+    legacy_record = workspace_store.get_node_record("node-legacy")
+
+    assert sqlite_record is not None
+    assert legacy_record is None
+    connection = open_state_db(create=False)
+    assert connection is not None
+    try:
+        sqlite_row = connection.execute(
+            "SELECT id FROM nodes WHERE id = ?",
+            ("node-sqlite",),
+        ).fetchone()
+        legacy_row = connection.execute(
+            "SELECT id FROM nodes WHERE id = ?",
+            ("node-legacy",),
+        ).fetchone()
+    finally:
+        connection.close()
+    assert sqlite_row is not None
+    assert legacy_row is None
+    workspace_store.reset_cache()