mainsequence-metatable 0.1.49.dev78__tar.gz → 0.1.50.dev79__tar.gz

{mainsequence_metatable-0.1.49.dev78/src/mainsequence_metatable.egg-info → mainsequence_metatable-0.1.50.dev79}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mainsequence-metatable
-Version: 0.1.49.dev78
+Version: 0.1.50.dev79
 Summary: Main Sequence MetaTables Python client and standalone API
 Author-email: Main Sequence GmbH <dev@main-sequence.io>
 License-Expression: MIT

{mainsequence_metatable-0.1.49.dev78 → mainsequence_metatable-0.1.50.dev79}/docs/adr/api/0002-application-administration-and-table-ownership.md

@@ -1,5 +1,10 @@
 # ADR 0002: Application administration and table ownership
 
+> Amendment (2026-10-20): In Local mode the operator, the SDK identity running the local
+> API, is the Organization admin of that runtime whatever their platform flag. A local
+> SQLite runtime, its catalog and its credentials belong to that one person, so admin
+> admission below applies to hosted runtimes only.
+
 > Amendment (2026-10-19): [ADR 0024](0024-namespace-and-table-access-roles.md) replaces Reader/Writer
 > with roles (`metadata_viewer`, `data_viewer`, `data_writer`, `editor`, `owner`) checked as actions.
 > Any person creates a namespace and owns it, namespace owners grant on it instead of

{mainsequence_metatable-0.1.49.dev78 → mainsequence_metatable-0.1.50.dev79}/docs/operations/local-runtime.md

@@ -203,7 +203,8 @@ metatables credentials remove-unused CREDENTIAL_UUID --database /absolute/path/m
 ```
 
 Pass `--configuration /absolute/path/configuration.yaml` for a different deployment
-configuration. These commands require an authenticated platform admin. Import is
+configuration. These commands require a signed-in SDK session, not the platform admin
+flag: the local catalog and its keys belong to the operator. Import is
 only for existing local references from the previous SDK-backed implementation;
 it reads the supported SDK in its valid hosted context, preserves UUIDs, validates
 affected enabled connections, and commits atomically. It never deletes SDK Secrets.

{mainsequence_metatable-0.1.49.dev78 → mainsequence_metatable-0.1.50.dev79}/docs/security/index.md

@@ -9,14 +9,16 @@ creates its application's namespace on its first run, and the people who manage
 Job manage that namespace's access. Nobody needs to become an Organization admin to
 deploy an application or maintain its tables.
 
-The API enforces this model in both local and hosted runtimes. The Admin UI and
+The API enforces this model in both local and hosted runtimes. In Local mode the person
+running the API administers their own SQLite runtime and holds every action, whatever
+their platform admin flag. The Admin UI and
 Python client use the same access endpoints. [ADR 0024](../adr/api/0024-namespace-and-table-access-roles.md)
 records the role model; [ADR 0002](../adr/api/0002-application-administration-and-table-ownership.md)
 records the separation from application administration.
 
 **Applications run Alembic through the client using their environment database login.**
 Direct database connections and general client-side Alembic execution remain blocked.
-Admins initialize and upgrade MetaTables system tables in Local Settings; a hosted
+The local operator initializes and upgrades MetaTables system tables in Local Settings; a hosted
 deployment's migration Job does so for its declared runtime database.
 
 ## Who owns each decision

{mainsequence_metatable-0.1.49.dev78 → mainsequence_metatable-0.1.50.dev79}/docs/security/permissions.md

@@ -28,9 +28,14 @@ never grant or revoke roles. A workload creates a namespace only by registering
 into a free name, and then holds `editor` on it. They use the roles granted to them or
 to their Teams.
 
-Initial runtime setup must check the platform admin fact before the application
-catalog exists. Configuring a pending database does not make the first caller an
-admin.
+In Local mode the operator, the SDK identity running the local API, is the admin of
+that runtime for every row above, whatever their platform admin flag: the SQLite file,
+its catalog and its local credentials are theirs. This includes setting up the
+runtime and the `metatables credentials` commands.
+
+Hosted runtime setup belongs to the deployment's migration Job; Settings and the API
+check the platform admin fact. Configuring a pending database does not make the first
+caller an admin.
 
 ## Namespace actions and roles
 

{mainsequence_metatable-0.1.49.dev78 → mainsequence_metatable-0.1.50.dev79}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "mainsequence-metatable"
-version = "0.1.49.dev78"
+version = "0.1.50.dev79"
 description = "Main Sequence MetaTables Python client and standalone API"
 readme = "README.md"
 requires-python = ">=3.13"

{mainsequence_metatable-0.1.49.dev78 → mainsequence_metatable-0.1.50.dev79/src/mainsequence_metatable.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mainsequence-metatable
-Version: 0.1.49.dev78
+Version: 0.1.50.dev79
 Summary: Main Sequence MetaTables Python client and standalone API
 Author-email: Main Sequence GmbH <dev@main-sequence.io>
 License-Expression: MIT

{mainsequence_metatable-0.1.49.dev78 → mainsequence_metatable-0.1.50.dev79}/src/metatables/api/app/auth/boundary.py

@@ -49,6 +49,12 @@ def workload_checker(uid: str) -> Callable[[], bool]:
     return check
 
 
+def local_operator_is_admin(state: RuntimeState) -> bool:
+    """Local mode serves only its operator's own SQLite runtime, so they administer it
+    whatever their platform admin flag. Developer mode keeps the platform's flag."""
+    return state.config.local_mode
+
+
 def admit_request(request: Request) -> AdmittedCaller:
     # The first dependency of nearly every route: the request's first step on a route thread.
     thread_started()
@@ -65,7 +71,8 @@ def admit_request(request: Request) -> AdmittedCaller:
             state.identity.user_uid, lambda: sdk_actor_facts(state.identity.user_uid),
         )
         return AdmittedCaller(
-            user_uid=state.identity.user_uid, active_team_uids=teams, is_admin=admin,
+            user_uid=state.identity.user_uid, active_team_uids=teams,
+            is_admin=local_operator_is_admin(state) or admin,
             environment_uid=UUID(environment_uid) if environment_uid else None,
         )
     caller = logged_user()

{mainsequence_metatable-0.1.49.dev78 → mainsequence_metatable-0.1.50.dev79}/src/metatables/api/app/credential_admin.py

@@ -27,9 +27,8 @@ from metatables.api.backend.persistence.models import DataSource
 def local_store(database: Path, configuration: Path):
     deployment = DeploymentConfiguration.load(configuration)
     deployment.require_development()
+    # The local catalog and its key directory belong to the operator; no platform admin flag.
     identity = resolve_sdk_user_identity()
-    if not identity.actor_facts or not identity.actor_facts[1]:
-        raise RuntimeError("Credential administration requires platform admin access.")
     if not database.is_absolute() or not database.is_file():
         raise RuntimeError("Choose the existing local catalog's absolute database path.")
     from metatables.api.backend.backends.registry import engine_descriptor

{mainsequence_metatable-0.1.49.dev78 → mainsequence_metatable-0.1.50.dev79}/tests/auth/test_local_mode.py

@@ -167,7 +167,9 @@ def test_shared_api_accepts_clients_from_any_checkout_and_api_commits(monkeypatc
 
 
 def as_person(monkeypatch, client=None):
-    """Continue as an ordinary person: admins hold every action (ADR 0024)."""
+    """Continue as an ordinary person, as developer-mode admission would admit them:
+    admins hold every action (ADR 0024) and the local operator is always one."""
+    monkeypatch.setattr("metatables.api.app.auth.boundary.local_operator_is_admin", lambda state: False)
     monkeypatch.setattr("metatables.api.app.auth.boundary.sdk_actor_facts", lambda user_uid: (frozenset(), False))
     if client is not None:
         client.app.state.runtime.actor_facts_cache._values.clear()

{mainsequence_metatable-0.1.49.dev78 → mainsequence_metatable-0.1.50.dev79}/tests/auth/test_platform_fact_cache.py

@@ -23,7 +23,11 @@ def hosted_request():
 
 @pytest.fixture
 def caller(monkeypatch):
-    """The developer's facts; hosted callers' facts arrive with each verified assertion."""
+    """The developer's facts; hosted callers' facts arrive with each verified assertion.
+
+    Developer-mode admission keeps the platform's admin flag; Local mode's operator is
+    always admin, so it cannot show the flag's expiry."""
+    from mainsequence import code_repository_context
     from mainsequence.client.models_user import User
 
     user, team = uuid4(), uuid4()
@@ -35,7 +39,9 @@ def caller(monkeypatch):
         return current
     monkeypatch.setattr(User, "get_authenticated_user_details", classmethod(lookup))
     monkeypatch.setattr(User, "get_logged_user", classmethod(lambda cls: proofs.append(cls)))
-    state = RuntimeState(config=RuntimeConfig(local_mode=True), identity=LocalIdentity(user),
+    monkeypatch.setattr(code_repository_context, "get_code_repository_context",
+                        lambda: SimpleNamespace(organization_environment_uid=None))
+    state = RuntimeState(config=RuntimeConfig(local_mode=False, developer_mode=True), identity=LocalIdentity(user),
                          actor_facts_cache=PlatformCache(clock=lambda: now[0]))
     req = SimpleNamespace(app=SimpleNamespace(state=SimpleNamespace(runtime=state)),
                           state=SimpleNamespace())
@@ -58,7 +64,7 @@ def test_facts_last_one_hour_without_sliding_expiry(caller):
     fresh = boundary.admit_request(f.request)
     assert not fresh.is_admin and fresh.active_team_uids == frozenset()
     assert len(f.calls) == 2
-    assert f.proofs == []  # Local admission never consults request identity.
+    assert f.proofs == []  # SDK-session admission never consults request identity.
 
 
 @pytest.mark.parametrize("failure", ["inactive", "wrong_user", "missing_facts", "unavailable"])

{mainsequence_metatable-0.1.49.dev78 → mainsequence_metatable-0.1.50.dev79}/tests/auth/test_runtime_bootstrap.py

@@ -706,6 +706,18 @@ def trusted_platform_admin_for_runtime_lifecycle(monkeypatch):
     monkeypatch.setattr("metatables.api.app.auth.boundary.sdk_actor_facts", lambda user_uid: (frozenset(), True))
 
 
+def test_local_operator_administers_the_runtime_without_platform_admin(bootstrap_client, monkeypatch):
+    monkeypatch.setattr("metatables.api.app.auth.boundary.sdk_actor_facts", lambda user_uid: (frozenset(), False))
+    client, path, _ = bootstrap_client
+    bootstrap = client.get("/runtime-context/").json()["bootstrap"]
+    assert bootstrap["can_configure"] is True
+    assert bootstrap["candidate"]["configuration"]["path"] == str(path)
+    response = client.post("/runtime-bootstrap/migrate/")
+    assert response.status_code == 200, response.text
+    assert response.json()["active"] is True
+    assert client.get("/caller/").json()["is_admin"] is True
+
+
 def test_the_catalog_pool_holds_serving_concurrency_connections(bootstrap_client):
     client, _, _ = bootstrap_client
     assert client.post("/runtime-bootstrap/migrate/").status_code == 200

{mainsequence_metatable-0.1.49.dev78 → mainsequence_metatable-0.1.50.dev79}/tests/e2e/test_application_owned_migrations.py

@@ -441,7 +441,7 @@ def test_offline_and_explicit_url_authoring_do_not_require_api(providers, tmp_pa
 
 
 @pytest.mark.parametrize("api_runtime", ["sqlite"], indirect=True)
-def test_connection_checks_provider_identity_and_all_catalog_writers(api_runtime, providers):
+def test_connection_checks_provider_identity_and_all_catalog_writers(api_runtime, providers, monkeypatch):
     import requests
 
     from metatables import MetaTable
@@ -469,6 +469,7 @@ def test_connection_checks_provider_identity_and_all_catalog_writers(api_runtime
                                                  principal_uid=runtime.identity.user_uid, role="editor")
         session.commit()
     # As an ordinary person: admins hold every action (ADR 0024).
+    monkeypatch.setattr("metatables.api.app.auth.boundary.local_operator_is_admin", lambda state: False)
     runtime.actor_facts_cache.seed(runtime.identity.user_uid, (frozenset(), False), expires_at=float("inf"))
     denied = requests.post(url, headers=headers, json={}, timeout=5)
     assert denied.status_code == 403 and "uri" not in denied.json()

{mainsequence_metatable-0.1.49.dev78 → mainsequence_metatable-0.1.50.dev79}/tests/e2e/test_run_logs.py

@@ -168,6 +168,7 @@ def test_runner_capture_history_filter_pagination_restart_and_revocation(log_app
         response = restarted.get(url, params={"event": "example.produced"})
         assert len(response.json()["rows"]) == 4
     # As an ordinary person: admins hold every action (ADR 0024).
+    monkeypatch.setattr("metatables.api.app.auth.boundary.local_operator_is_admin", lambda state: False)
     f.state.actor_facts_cache.seed(f.state.identity.user_uid, (frozenset(), False), expires_at=float("inf"))
     with f.state.bootstrap.factory() as session:
         GrantRepository(session).revoke_table_grant(
@@ -177,7 +178,7 @@ def test_runner_capture_history_filter_pagination_restart_and_revocation(log_app
     assert f.http.get(url, params={**query, "cursor": page["next_cursor"]}).status_code == 404
 
 
-def test_invocation_logs_merge_the_readable_attempts_of_one_invocation(log_app):
+def test_invocation_logs_merge_the_readable_attempts_of_one_invocation(log_app, monkeypatch):
     f = log_app
     standalone = start(f)
     emit(f, standalone, "standalone.produced")
@@ -229,6 +230,7 @@ def test_invocation_logs_merge_the_readable_attempts_of_one_invocation(log_app):
     assert rest.status_code == 200 and rest.json()["rows"][0]["run_uid"] == root.uid
     assert f.http.get(url, params={"run_uid": standalone.uid}).status_code == 422
     # As an ordinary person: admins hold every action (ADR 0024).
+    monkeypatch.setattr("metatables.api.app.auth.boundary.local_operator_is_admin", lambda state: False)
     f.state.actor_facts_cache.seed(f.state.identity.user_uid, (frozenset(), False), expires_at=float("inf"))
     with f.state.bootstrap.factory() as session:
         GrantRepository(session).revoke_table_grant(table_uid=upstream_table, principal_kind="user",

{mainsequence_metatable-0.1.49.dev78 → mainsequence_metatable-0.1.50.dev79}/tests/e2e/test_sqlite_runtime.py

@@ -464,6 +464,7 @@ def test_example_setup_migrates_in_client_and_reuses_the_selected_runtime(api_ru
             grant.access_level = 'data_viewer'
         session.commit()
     # As an ordinary person: admins hold every action (ADR 0024).
+    monkeypatch.setattr('metatables.api.app.auth.boundary.local_operator_is_admin', lambda state: False)
     runtime.actor_facts_cache.seed(runtime.identity.user_uid, (frozenset(), False), expires_at=float('inf'))
     with pytest.raises(Exception):
         setup_metatables()

{mainsequence_metatable-0.1.49.dev78 → mainsequence_metatable-0.1.50.dev79}/tests/integrations/test_credential_store.py

@@ -228,10 +228,13 @@ def test_failed_import_validation_rolls_back_new_credentials(vault, monkeypatch)
         assert session.scalar(select(DataSource)).configuration["password_secret_uid"] == str(uid)
 
 
-def test_credential_cli_requires_admin_before_accessing_store(vault, tmp_path, monkeypatch):
+def test_credential_cli_opens_the_local_store_without_platform_admin(vault, tmp_path, monkeypatch):
     from metatables.api.app.credential_admin import local_store
+    uid = save(vault)
     configuration = tmp_path / "configuration.yaml"
-    configuration.write_text("local_mode_available: true\n")
-    monkeypatch.setattr("metatables.api.app.credential_admin.resolve_sdk_user_identity", lambda: SimpleNamespace(actor_facts=(frozenset(), False)))
-    with pytest.raises(RuntimeError, match="admin access"), local_store(vault.database, configuration):
-        pytest.fail("Nonadmin opened the store")
+    configuration.write_text("local_mode_available: true\nlocal_credentials:\n  provider: file\n  key_directory: keys\n")
+    monkeypatch.setattr("metatables.api.app.credential_admin.resolve_sdk_user_identity",
+                        lambda: SimpleNamespace(user_uid=vault.user, actor_facts=(frozenset(), False)))
+    with local_store(vault.database, configuration) as (store, factory, user):
+        assert user == vault.user
+        assert store.resolve(uid, "database_password") == "  private-password  "

{mainsequence_metatable-0.1.49.dev78 → mainsequence_metatable-0.1.50.dev79}/uv.lock

@@ -854,7 +854,7 @@ mcp = [
 
 [[package]]
 name = "mainsequence-metatable"
-version = "0.1.49"
+version = "0.1.50"
 source = { editable = "." }
 dependencies = [
     { name = "alembic" },