chore: merge master into dev/4.11.x

2026-08-19 00:40:59 +00:00 · 2026-08-14 16:04:52 +08:00
parent 444024c5b4 1f1a3aff55
commit f94243c725
121 changed files with 9173 additions and 5846 deletions
@@ -106,7 +106,12 @@ async def plugin_security_api(plugin_module):
    application.plugin_connector.require_workspace_context = AsyncMock()
    application.plugin_connector.list_plugins = AsyncMock(return_value=[raw_plugin])
    application.plugin_connector.get_plugin_info = AsyncMock(return_value=raw_plugin)
-    application.plugin_connector.get_debug_info = AsyncMock(return_value={'plugin_debug_key': 'runtime-debug-secret'})
+    application.plugin_connector.get_debug_info = AsyncMock(
+        return_value={
+            'plugin_debug_key': 'runtime-debug-secret',
+            'expires_at': '2026-08-04T12:00:00Z',
+        }
+    )
    application.plugin_connector.get_plugin_logs = AsyncMock(return_value=['private runtime line'])
    application.plugin_connector.set_plugin_config = AsyncMock()

@@ -230,10 +235,22 @@ async def test_debug_key_requires_resource_manage_permission(plugin_security_api
    assert operator_denied.status_code == 403
    assert allowed.status_code == 200
    assert (await allowed.get_json())['data'] == {
-        'debug_url': 'http://localhost:5401',
+        'debug_url': 'ws://localhost:5401/plugin/debug/ws',
        'plugin_debug_key': 'runtime-debug-secret',
+        'expires_at': '2026-08-04T12:00:00Z',
    }
-    application.plugin_connector.get_debug_info.assert_awaited_once_with()
+    application.plugin_connector.get_debug_info.assert_awaited_once()
+
+
+@pytest.mark.asyncio
+async def test_debug_info_uses_websocket_endpoint_for_legacy_config(plugin_security_api):
+    application, client, _ = plugin_security_api
+    application.instance_config.data['plugin'].pop('display_plugin_debug_url')
+
+    response = await client.get('/api/v1/plugins/debug-info', headers=_headers('manager-token'))
+
+    assert response.status_code == 200
+    assert (await response.get_json())['data']['debug_url'] == 'ws://localhost:5401/plugin/debug/ws'


@pytest.mark.asyncio
@@ -2,6 +2,7 @@

 from __future__ import annotations

+import datetime
 from types import SimpleNamespace
 from unittest.mock import AsyncMock, Mock
 from urllib.parse import parse_qs, urlsplit
@@ -14,6 +15,7 @@ from langbot.pkg.api.http.controller.groups.user import UserRouterGroup

 pytestmark = pytest.mark.integration
 WORKSPACE_UUID = '11111111-1111-4111-8111-111111111111'
+WORKSPACE_CREATED_AT = datetime.datetime(2026, 1, 2, 3, 4, 5, tzinfo=datetime.UTC)


@pytest.fixture
@@ -58,6 +60,12 @@ async def space_oauth_api():
        return_value={'account_uuid': 'account-a', 'workspace_uuid': WORKSPACE_UUID}
    )
    application.workspace_collaboration_service.resolve_account_workspace = AsyncMock(return_value=access)
+    application.workspace_service.get_execution_binding = AsyncMock(
+        return_value=SimpleNamespace(
+            workspace_uuid=WORKSPACE_UUID,
+            workspace_created_at=WORKSPACE_CREATED_AT,
+        )
+    )
    application.space_service.get_oauth_authorize_url = Mock(
        side_effect=lambda redirect_uri, state: f'https://space.example/authorize?state={state}'
    )
@@ -157,34 +165,51 @@ async def test_bind_state_is_account_bound_and_requires_authentication(space_oau


@pytest.mark.asyncio
-async def test_redirect_origin_and_callback_path_are_restricted(space_oauth_api):
+async def test_redirect_allows_any_http_or_https_origin(space_oauth_api):
    _, client = space_oauth_api

-    wrong_origin = await client.get(
-        '/api/v1/user/space/authorize-url',
-        query_string={'redirect_uri': 'https://evil.example/auth/space/callback'},
-        headers={'Origin': 'http://localhost'},
-    )
-    wrong_path = await client.get(
-        '/api/v1/user/space/authorize-url',
-        query_string={'redirect_uri': 'http://localhost/arbitrary'},
-        headers={'Origin': 'http://localhost'},
-    )
-    forged_origin = await client.get(
-        '/api/v1/user/space/authorize-url',
-        query_string={'redirect_uri': 'https://evil.example/auth/space/callback'},
-        headers={'Origin': 'https://evil.example'},
-    )
-    forged_host = await client.get(
-        '/api/v1/user/space/authorize-url',
-        query_string={'redirect_uri': 'https://evil.example/auth/space/callback'},
-        headers={'Host': 'evil.example'},
-    )
+    responses = [
+        await client.get(
+            '/api/v1/user/space/authorize-url',
+            query_string={'redirect_uri': redirect_uri},
+            headers={'Origin': 'https://irrelevant.example'},
+        )
+        for redirect_uri in (
+            'https://langbot.example/auth/space/callback',
+            'https://gateway.example:8443/auth/space/callback',
+            'https://192.0.2.10/auth/space/callback',
+            'http://localhost:5300/auth/space/callback',
+            'http://127.0.0.1:5300/auth/space/callback',
+            'http://[::1]:5300/auth/space/callback',
+            'http://langbot.example/auth/space/callback',
+            'http://192.0.2.10:5300/auth/space/callback',
+        )
+    ]

-    assert (await wrong_origin.get_json())['code'] == 1
-    assert (await wrong_path.get_json())['code'] == 1
-    assert (await forged_origin.get_json())['code'] == 1
-    assert (await forged_host.get_json())['code'] == 1
+    assert all(response.status_code == 200 for response in responses)
+    payloads = [await response.get_json() for response in responses]
+    assert all(payload['code'] == 0 for payload in payloads)
+
+
+@pytest.mark.asyncio
+async def test_redirect_rejects_invalid_callback_shape(space_oauth_api):
+    _, client = space_oauth_api
+
+    responses = [
+        await client.get(
+            '/api/v1/user/space/authorize-url',
+            query_string={'redirect_uri': redirect_uri},
+        )
+        for redirect_uri in (
+            'https://langbot.example/arbitrary',
+            'https://langbot.example/auth/space/callback?next=https://evil.example',
+            'https://user@langbot.example/auth/space/callback',
+            'https://langbot.example/auth/space/callback#fragment',
+        )
+    ]
+
+    payloads = [await response.get_json() for response in responses]
+    assert all(payload['code'] == 1 for payload in payloads)


@pytest.mark.asyncio
@@ -234,7 +259,11 @@ async def test_login_callback_requires_and_consumes_server_state(space_oauth_api
    assert response.status_code == 200
    assert (await response.get_json())['data']['token'] == 'space-login-token'
    application.user_service.consume_space_oauth_state_details.assert_awaited_once_with('opaque-login-state', 'login')
-    application.space_service.exchange_oauth_code.assert_awaited_once_with('oauth-code')
+    application.space_service.exchange_oauth_code.assert_awaited_once_with(
+        'oauth-code',
+        [WORKSPACE_UUID],
+        {WORKSPACE_UUID: int(WORKSPACE_CREATED_AT.timestamp())},
+    )


@pytest.mark.asyncio
@@ -0,0 +1,70 @@
+from __future__ import annotations
+
+import pytest
+import sqlalchemy as sa
+from sqlalchemy.ext.asyncio import create_async_engine
+
+from langbot.pkg.persistence.alembic_runner import run_alembic_stamp, run_alembic_upgrade
+
+
+@pytest.mark.asyncio
+async def test_membership_source_migration_backfills_existing_rows_as_local_and_enforces_constraint(tmp_path):
+    engine = create_async_engine(f'sqlite+aiosqlite:///{tmp_path / "membership-source.db"}')
+    try:
+        async with engine.begin() as connection:
+            await connection.execute(
+                sa.text(
+                    """
+                    CREATE TABLE workspace_memberships (
+                        uuid VARCHAR(36) PRIMARY KEY,
+                        workspace_uuid VARCHAR(36) NOT NULL,
+                        account_uuid VARCHAR(36) NOT NULL,
+                        role VARCHAR(32) NOT NULL,
+                        status VARCHAR(32) NOT NULL,
+                        projection_revision BIGINT NOT NULL DEFAULT 0,
+                        created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+                        updated_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
+                    )
+                    """
+                )
+            )
+            await connection.execute(
+                sa.text(
+                    """
+                    INSERT INTO workspace_memberships
+                        (uuid, workspace_uuid, account_uuid, role, status, projection_revision)
+                    VALUES
+                        ('00000000-0000-4000-8000-000000000001', 'workspace', 'local-account',
+                         'viewer', 'active', 0),
+                        ('00000000-0000-4000-8000-000000000002', 'workspace', 'cloud-account',
+                         'viewer', 'active', 0)
+                    """
+                )
+            )
+
+        await run_alembic_stamp(engine, '0019_single_workspace_owner')
+        await run_alembic_upgrade(engine, 'head')
+
+        async with engine.connect() as connection:
+            rows = (
+                await connection.execute(sa.text('SELECT uuid, source FROM workspace_memberships ORDER BY uuid'))
+            ).all()
+            columns = await connection.run_sync(
+                lambda sync_connection: {
+                    column['name']: column
+                    for column in sa.inspect(sync_connection).get_columns('workspace_memberships')
+                }
+            )
+        assert rows == [
+            ('00000000-0000-4000-8000-000000000001', 'local'),
+            ('00000000-0000-4000-8000-000000000002', 'local'),
+        ]
+        assert columns['source']['nullable'] is False
+
+        with pytest.raises(sa.exc.IntegrityError):
+            async with engine.begin() as connection:
+                await connection.execute(
+                    sa.text("UPDATE workspace_memberships SET source = 'guessed-from-user-source'")
+                )
+    finally:
+        await engine.dispose()
@@ -9,8 +9,11 @@ Run: uv run pytest tests/integration/persistence/test_migrations.py -q

 from __future__ import annotations

+import json
+
 import pytest
 import sqlalchemy
+from sqlalchemy import text
 from sqlalchemy.ext.asyncio import create_async_engine

 from langbot.pkg.entity.persistence.base import Base
@@ -105,7 +108,7 @@ class TestSQLiteMigrationUpgrade:
        await run_alembic_upgrade(sqlite_engine, 'head')

        assert await get_alembic_current(sqlite_engine) == _get_script_head()
-        assert _get_script_head() == '0020_merge_agent_cloud_heads'
+        assert _get_script_head() == '0022_merge_agent_reasoning_heads'

    @pytest.mark.asyncio
    async def test_upgrade_from_development_workspace_head_to_merged_head(self, sqlite_engine):
@@ -117,7 +120,18 @@ class TestSQLiteMigrationUpgrade:
        await run_alembic_upgrade(sqlite_engine, 'head')

        assert await get_alembic_current(sqlite_engine) == _get_script_head()
-        assert _get_script_head() == '0020_merge_agent_cloud_heads'
+        assert _get_script_head() == '0022_merge_agent_reasoning_heads'
+
+    @pytest.mark.asyncio
+    async def test_upgrade_from_reasoning_config_head_to_merged_head(self, sqlite_engine):
+        """A database that already ran the feature migration must remain upgradable."""
+        async with sqlite_engine.begin() as conn:
+            await conn.run_sync(Base.metadata.create_all)
+
+        await run_alembic_stamp(sqlite_engine, '0018_llm_reasoning_config')
+        await run_alembic_upgrade(sqlite_engine, 'head')
+
+        assert await get_alembic_current(sqlite_engine) == '0022_merge_agent_reasoning_heads'

    @pytest.mark.asyncio
    async def test_upgrade_from_baseline_to_head(self, sqlite_engine):
@@ -214,6 +228,66 @@ class TestSQLiteMigrationUpgrade:
        await run_alembic_upgrade(sqlite_engine, 'head')
        assert await get_alembic_current(sqlite_engine) == _get_script_head()

+    @pytest.mark.asyncio
+    async def test_reasoning_config_migrates_existing_models(self, sqlite_engine):
+        """Upgrade from 0017 backfills reasoning config and keeps a database default."""
+        async with sqlite_engine.begin() as conn:
+            await conn.execute(
+                text(
+                    """
+                    CREATE TABLE llm_models (
+                        uuid VARCHAR(255) PRIMARY KEY,
+                        name VARCHAR(255) NOT NULL,
+                        provider_uuid VARCHAR(255) NOT NULL,
+                        abilities JSON NOT NULL,
+                        context_length INTEGER,
+                        extra_args JSON NOT NULL,
+                        prefered_ranking INTEGER NOT NULL DEFAULT 0
+                    )
+                    """
+                )
+            )
+            await conn.execute(
+                text(
+                    """
+                    INSERT INTO llm_models (
+                        uuid, name, provider_uuid, abilities, extra_args, prefered_ranking
+                    ) VALUES (
+                        'existing-model', 'Existing Model', 'provider', '[]', '{}', 0
+                    )
+                    """
+                )
+            )
+
+        await run_alembic_stamp(sqlite_engine, '0017_oss_workspace_identity')
+        await run_alembic_upgrade(sqlite_engine, 'head')
+
+        async with sqlite_engine.begin() as conn:
+            columns = await conn.run_sync(lambda sync_conn: sqlalchemy.inspect(sync_conn).get_columns('llm_models'))
+            reasoning_column = next(column for column in columns if column['name'] == 'reasoning_config')
+            assert reasoning_column['nullable'] is False
+
+            existing_value = (
+                await conn.execute(text("SELECT reasoning_config FROM llm_models WHERE uuid = 'existing-model'"))
+            ).scalar_one()
+            assert json.loads(existing_value) == {'level': 'provider_default'}
+
+            await conn.execute(
+                text(
+                    """
+                    INSERT INTO llm_models (
+                        uuid, name, provider_uuid, abilities, extra_args, prefered_ranking
+                    ) VALUES (
+                        'new-model', 'New Model', 'provider', '[]', '{}', 0
+                    )
+                    """
+                )
+            )
+            new_value = (
+                await conn.execute(text("SELECT reasoning_config FROM llm_models WHERE uuid = 'new-model'"))
+            ).scalar_one()
+            assert json.loads(new_value) == {'level': 'provider_default'}
+

 class TestSQLiteMigrationFreshDatabase:
    """Tests for fresh database workflow."""
@@ -85,6 +85,32 @@ async def clean_database(postgres_engine: AsyncEngine):
    await clean()


+async def test_upgrade_adds_3072_dimension_index_and_constraint(
+    postgres_engine: AsyncEngine,
+    clean_database,
+) -> None:
+    async with postgres_engine.begin() as conn:
+        await conn.execute(text('CREATE EXTENSION IF NOT EXISTS vector'))
+        await conn.run_sync(Base.metadata.create_all)
+    await run_alembic_stamp(postgres_engine, '0010_scope_resources')
+    await run_alembic_upgrade(postgres_engine, 'head')
+
+    async with postgres_engine.connect() as conn:
+        constraint = await conn.scalar(
+            text(
+                'SELECT pg_get_constraintdef(oid) FROM pg_constraint '
+                "WHERE conrelid = 'langbot_vectors'::regclass "
+                "AND conname = 'ck_langbot_vectors_embedding_dimension_enabled'"
+            )
+        )
+        assert '3072' in constraint
+        index_definition = await conn.scalar(
+            text("SELECT indexdef FROM pg_indexes WHERE indexname = 'ix_langbot_vectors_hnsw_cosine_3072'")
+        )
+        assert 'halfvec(3072)' in index_definition
+        assert 'halfvec_cosine_ops' in index_definition
+
+
 async def test_legacy_upgrade_temporarily_suspends_and_restores_source_rls_for_unprivileged_owner(
    postgres_url: str,
    postgres_engine: AsyncEngine,
@@ -92,7 +92,7 @@ def _application(postgres_url: str, *, runtime_role: str = 'langbot_runtime_not_
                    'use': 'pgvector',
                    'pgvector': {
                        'use_business_database': True,
-                        'allowed_dimensions': [384, 512, 768, 1024, 1536],
+                        'allowed_dimensions': [384, 512, 768, 1024, 1536, 3072],
                    },
                },
            }