druks 0.0.1__tar.gz

druks-0.0.1/.gitignore

@@ -0,0 +1,22 @@
+.env
+.claude/
+.DS_Store
+.venv/
+.pytest_cache/
+.ruff_cache/
+.idea/
+.tmp/
+/tmp/
+__pycache__/
+*.py[cod]
+/.coverage
+/htmlcov/
+/data/
+/frontend/data/
+secrets/
+# druks/secrets is source (the encrypted-column fields), not stored secrets.
+!backend/druks/secrets/
+# Frontend build output — produced by `npm --prefix frontend run build`.
+/dist/
+# ADRs are private, kept out of the repo.
+/docs/adr/

druks-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Paulo Alvarado Garcia
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

druks-0.0.1/PKG-INFO

@@ -0,0 +1,142 @@
+Metadata-Version: 2.4
+Name: druks
+Version: 0.0.1
+Summary: Platform for durable agent orchestration.
+Project-URL: Documentation, https://github.com/clawhaven/druks/tree/main/docs
+Project-URL: Issues, https://github.com/clawhaven/druks/issues
+Project-URL: Repository, https://github.com/clawhaven/druks
+Author: Paulo Alvarado Garcia
+License-Expression: MIT
+License-File: LICENSE
+Keywords: agents,dbos,durable-execution,orchestration,workflows
+Classifier: Development Status :: 3 - Alpha
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Requires-Python: >=3.11
+Requires-Dist: alembic>=1.13
+Requires-Dist: apprise>=1.9
+Requires-Dist: asyncssh>=2.22
+Requires-Dist: blinker>=1.9
+Requires-Dist: croniter>=6.2.2
+Requires-Dist: cryptography>=48.0.1
+Requires-Dist: dbos>=2.26
+Requires-Dist: drukbox-python-sdk>=0.0.6
+Requires-Dist: fastapi>=0.138.0
+Requires-Dist: githubkit[auth-app]>=0.15.5
+Requires-Dist: httpx>=0.28.0
+Requires-Dist: jinja2>=3.1
+Requires-Dist: psycopg[binary]>=3.2
+Requires-Dist: pydantic-settings>=2.14.2
+Requires-Dist: pydantic>=2.12.0
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: redis>=8
+Requires-Dist: sqlalchemy>=2.0
+Requires-Dist: uuid-utils>=0.16.0
+Requires-Dist: uvicorn>=0.38.0
+Description-Content-Type: text/markdown
+
+<p align="center">
+  <picture>
+    <source media="(prefers-color-scheme: dark)" srcset="docs/assets/logo/web/DruksLogo_White.svg" />
+    <img src="docs/assets/logo/web/DruksLogo_Black.svg" alt="Druks" width="140" />
+  </picture>
+</p>
+
+# Druks
+
+> [!WARNING]
+> Druks is under active development. Expect breaking changes and rough edges
+> before 1.0; `main` and `latest` are edge builds, not stable releases.
+
+Druks is a platform for **durable agent orchestration**. It gives
+long-running agent applications a durable workflow engine, human gates,
+sandboxed execution, events, webhooks, settings, and an operator dashboard.
+The application supplies the domain logic as an independently packaged
+extension.
+
+An ordinary agent script loses its place when the process dies. A Druks
+workflow records the result of each completed durable operation in Postgres.
+After a restart or deploy, Druks replays the workflow and reuses those recorded
+results instead of repeating completed work. If the process was interrupted
+*inside* an operation, that operation may run again, so side effects still need
+idempotency. [Durability and recovery](docs/concepts.md#durability-and-recovery)
+explains the exact boundary.
+
+## Install
+
+The installer supports three sandbox profiles backed by
+[Drukbox](https://github.com/clawhaven/drukbox):
+
+- `exe` (default) and `aws`: remote sandbox VMs, with Druks and Drukbox in Compose
+- `docker`: local sandbox containers, with Drukbox running on the host
+
+For a remote install:
+
+```bash
+bash <(curl -fsSL https://raw.githubusercontent.com/clawhaven/druks/main/scripts/install.sh)
+```
+
+That command follows the edge channel while Druks has no stable release. Once
+versioned releases exist, install the script and image from the same tag as
+described in [the release process](docs/releasing.md#install-an-immutable-version).
+
+The first run creates `~/druks/.env`, generates secrets, and prints any values
+still required. Re-run the same command after filling them; it pulls images,
+runs migrations, and starts the stack. Re-running is also the upgrade path.
+See the [deployment runbook](deploy/README.md) for prerequisites, access
+control, verification, and rollback.
+
+For a laptop-only stack:
+
+```bash
+DRUKS_PROVIDER=docker bash <(curl -fsSL https://raw.githubusercontent.com/clawhaven/druks/main/scripts/install.sh)
+```
+
+Then follow [full local setup](docs/full-local.md) to start Drukbox and connect
+the agent harnesses. A complete installation needs GitHub Apps because the
+bundled `build` extension is installed; a standalone extension may have
+different integration requirements.
+
+```text
+trigger ──> extension workflow ──> durable step ──> agent ──> sandbox
+                 │                     │              │
+                 │                     │              └─ Claude or Codex harness
+                 │                     └─ result checkpointed in Postgres
+                 ├─ event ──> feed / extension reaction
+                 └─ gate  ──> wait for human or external system ──> resume
+```
+
+**Platform and applications stay separate**
+
+Druks owns the execution and operating substrate:
+
+- DBOS workflows and queues backed by Postgres
+- typed human gates, cancellation, schedules, and observable run state
+- Claude and Codex harness dispatch through isolated Drukbox sandboxes
+- append-only events, live feeds, webhooks, notifications, MCP servers, and skills
+- validated operator settings, encrypted MCP/OAuth secrets, and the dashboard shell
+- extension discovery, API namespaces, and independent migration histories
+
+An **extension** owns the application: its workflows, agents, domain models,
+routes, events, provider reactions, and optional dashboard pages. It is a normal
+Python distribution registered through the `druks.extensions` entry-point
+group. Installing the distribution registers it; Druks does not need an
+extension-specific plugin list.
+
+The bundled `build` extension is a concrete example. It coordinates coding
+agents through tickets and GitHub pull requests, but GitHub PR orchestration is
+`build` behavior—not the definition of Druks.
+
+## Documentation
+
+- **Evaluating Druks:** [Concepts and guarantees](docs/concepts.md)
+- **Installing locally:** [Full local setup](docs/full-local.md)
+- **Operating a remote stack:** [Deployment runbook](deploy/README.md)
+- **Configuring integrations and secrets:** [Configuration](docs/configuration.md)
+- **Building an application:** [Writing an extension](docs/writing-an-extension.md)
+- **Diagnosing a run or service:** [Troubleshooting](docs/troubleshooting.md)
+- **Contributing to Druks:** [Contribution guide](CONTRIBUTING.md)
+- **Reporting a vulnerability:** [Security policy](SECURITY.md)
+- **All documentation:** [Documentation index](docs/index.md)

druks-0.0.1/README.md

@@ -0,0 +1,103 @@
+<p align="center">
+  <picture>
+    <source media="(prefers-color-scheme: dark)" srcset="docs/assets/logo/web/DruksLogo_White.svg" />
+    <img src="docs/assets/logo/web/DruksLogo_Black.svg" alt="Druks" width="140" />
+  </picture>
+</p>
+
+# Druks
+
+> [!WARNING]
+> Druks is under active development. Expect breaking changes and rough edges
+> before 1.0; `main` and `latest` are edge builds, not stable releases.
+
+Druks is a platform for **durable agent orchestration**. It gives
+long-running agent applications a durable workflow engine, human gates,
+sandboxed execution, events, webhooks, settings, and an operator dashboard.
+The application supplies the domain logic as an independently packaged
+extension.
+
+An ordinary agent script loses its place when the process dies. A Druks
+workflow records the result of each completed durable operation in Postgres.
+After a restart or deploy, Druks replays the workflow and reuses those recorded
+results instead of repeating completed work. If the process was interrupted
+*inside* an operation, that operation may run again, so side effects still need
+idempotency. [Durability and recovery](docs/concepts.md#durability-and-recovery)
+explains the exact boundary.
+
+## Install
+
+The installer supports three sandbox profiles backed by
+[Drukbox](https://github.com/clawhaven/drukbox):
+
+- `exe` (default) and `aws`: remote sandbox VMs, with Druks and Drukbox in Compose
+- `docker`: local sandbox containers, with Drukbox running on the host
+
+For a remote install:
+
+```bash
+bash <(curl -fsSL https://raw.githubusercontent.com/clawhaven/druks/main/scripts/install.sh)
+```
+
+That command follows the edge channel while Druks has no stable release. Once
+versioned releases exist, install the script and image from the same tag as
+described in [the release process](docs/releasing.md#install-an-immutable-version).
+
+The first run creates `~/druks/.env`, generates secrets, and prints any values
+still required. Re-run the same command after filling them; it pulls images,
+runs migrations, and starts the stack. Re-running is also the upgrade path.
+See the [deployment runbook](deploy/README.md) for prerequisites, access
+control, verification, and rollback.
+
+For a laptop-only stack:
+
+```bash
+DRUKS_PROVIDER=docker bash <(curl -fsSL https://raw.githubusercontent.com/clawhaven/druks/main/scripts/install.sh)
+```
+
+Then follow [full local setup](docs/full-local.md) to start Drukbox and connect
+the agent harnesses. A complete installation needs GitHub Apps because the
+bundled `build` extension is installed; a standalone extension may have
+different integration requirements.
+
+```text
+trigger ──> extension workflow ──> durable step ──> agent ──> sandbox
+                 │                     │              │
+                 │                     │              └─ Claude or Codex harness
+                 │                     └─ result checkpointed in Postgres
+                 ├─ event ──> feed / extension reaction
+                 └─ gate  ──> wait for human or external system ──> resume
+```
+
+**Platform and applications stay separate**
+
+Druks owns the execution and operating substrate:
+
+- DBOS workflows and queues backed by Postgres
+- typed human gates, cancellation, schedules, and observable run state
+- Claude and Codex harness dispatch through isolated Drukbox sandboxes
+- append-only events, live feeds, webhooks, notifications, MCP servers, and skills
+- validated operator settings, encrypted MCP/OAuth secrets, and the dashboard shell
+- extension discovery, API namespaces, and independent migration histories
+
+An **extension** owns the application: its workflows, agents, domain models,
+routes, events, provider reactions, and optional dashboard pages. It is a normal
+Python distribution registered through the `druks.extensions` entry-point
+group. Installing the distribution registers it; Druks does not need an
+extension-specific plugin list.
+
+The bundled `build` extension is a concrete example. It coordinates coding
+agents through tickets and GitHub pull requests, but GitHub PR orchestration is
+`build` behavior—not the definition of Druks.
+
+## Documentation
+
+- **Evaluating Druks:** [Concepts and guarantees](docs/concepts.md)
+- **Installing locally:** [Full local setup](docs/full-local.md)
+- **Operating a remote stack:** [Deployment runbook](deploy/README.md)
+- **Configuring integrations and secrets:** [Configuration](docs/configuration.md)
+- **Building an application:** [Writing an extension](docs/writing-an-extension.md)
+- **Diagnosing a run or service:** [Troubleshooting](docs/troubleshooting.md)
+- **Contributing to Druks:** [Contribution guide](CONTRIBUTING.md)
+- **Reporting a vulnerability:** [Security policy](SECURITY.md)
+- **All documentation:** [Documentation index](docs/index.md)

druks-0.0.1/backend/druks/__init__.py

@@ -0,0 +1,3 @@
+__all__ = ["__version__"]
+
+__version__ = "0.1.0"

druks-0.0.1/backend/druks/agents.py

@@ -0,0 +1,230 @@
+import contextlib
+from collections.abc import AsyncIterator
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import TYPE_CHECKING, Any
+
+from dbos import DBOS, StepOptions
+from pydantic import BaseModel, ConfigDict
+
+from druks.database import db_session
+from druks.durable.activity import set_run_phase
+from druks.durable.engine import _step_engine, step_session
+from druks.durable.enums import AgentCallStatus
+from druks.durable.exceptions import WorkflowError
+from druks.durable.models import AgentCall, Artifact
+from druks.extensions.registry import agents
+from druks.harnesses.registry import get_harness_for_model
+from druks.prompts import render_prompt
+from druks.sandbox.client import sandbox_client
+from druks.sandbox.constants import MAX_AGENT_TIMEOUT_SECONDS
+from druks.settings import load_settings
+from druks.user_settings.models import SettingsOverride
+from druks.workflows import _in_step, current_workflow
+
+if TYPE_CHECKING:
+    from druks.sandbox.datastructures import AgentResult, Workspace
+    from druks.workflows import Workflow
+
+__all__ = ["Agent", "AgentOutput"]
+
+
+@contextlib.asynccontextmanager
+async def _runner(
+    workflow: "Workflow", host_id: str | None, workflow_id: str, step: str | None
+) -> AsyncIterator["Workspace"]:
+    # The agent always runs in a Workspace. A warm run attaches the run's held VM; the
+    # rest get a fresh ephemeral VM. Either way workflow.get_workspace() turns the VM into
+    # the runner — fresh per call, so nothing (connection or credential) is held across steps.
+    if host_id:
+        vm = sandbox_client.attach(host_id=host_id)
+    else:
+        vm = sandbox_client.ephemeral(idempotency_key=f"{workflow_id}:{step}")
+    async with vm as box:
+        yield await workflow.get_workspace(box)
+
+
+class AgentOutput(BaseModel):
+    """Base for an agent's structured output contract — the model an ``Agent``
+    declares as its ``contract``. The harness sends the model's schema to OpenAI's
+    strict structured-output validator on a Codex model, which requires every
+    object node to set ``additionalProperties: false`` and list every property in
+    ``required``: ``extra="forbid"`` gives the former, and declaring every field
+    without a default (optionals as required-but-nullable ``X | None``) gives the
+    latter — a field with a default 400s at runtime."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    def to_result(self) -> Any:
+        # What the caller gets back from an agent call: the validated output itself
+        # by default. Override to map the strict agent output onto a looser domain
+        # type — the seam that keeps the agent contract out of durable records,
+        # applied by the call so no caller ever invokes it.
+        return self
+
+    def get_artifact(self) -> dict[str, str]:
+        # The call's renderable output as {kind, title, content} — the platform persists
+        # it after the call. Empty unless the contract produces a reviewable document.
+        return {}
+
+
+@dataclass(frozen=True)
+class Agent:
+    contract: type[AgentOutput]
+    # Operator-tunable declared default: the model the agent runs unless it is
+    # overridden (per agent or globally) in settings. A family token
+    # (codex/claude) resolves to that family's operator-tunable model.
+    model: str
+    # Display label for the settings UI; ``id`` is shown when it's None.
+    name: str | None = None
+    # Short human-friendly blurb of what the agent does, shown in the settings UI.
+    description: str = ""
+    # The prompt template ``run`` renders. None for agents that build their
+    # prompt inline and drive the harness themselves (planning) instead of
+    # going through ``run``.
+    prompt: str | None = None
+    # Operator-tunable declared defaults, overridable per agent or globally.
+    # None inherits the global default (effort; timeout in seconds).
+    effort: str | None = None
+    timeout: int | None = None
+    # ``include_plugins=False`` skips the operator's plugin state for prompts
+    # that hit no MCP server.
+    include_plugins: bool = True
+    # ``id`` is the agent's durable key (settings, timeline, registry): the attribute
+    # name it's declared as, or an explicit ``id=`` for a standalone agent (a test, a
+    # one-off). ``extension`` is the owning Extension's name, read from the class in
+    # __set_name__ to group the settings UI — blank for a standalone agent (no owner).
+    id: str = field(default="", compare=False)
+    extension: str = field(init=False, compare=False, default="")
+
+    def __post_init__(self) -> None:
+        if self.id:  # an explicit id means a standalone agent — it registers itself now
+            agents.register(self)
+
+    def __set_name__(self, owner: type, attr: str) -> None:
+        if self.id:  # explicit id: already registered in __post_init__
+            return
+        object.__setattr__(self, "id", attr)
+        object.__setattr__(self, "extension", owner.name)
+        agents.register(self)
+
+    # The effective settings, resolved through the override store: per-agent
+    # override → the agent's declared value → the operator's global default.
+    # ``run`` uses these; callers that drive the harness themselves call them
+    # directly.
+    def get_model_name(self) -> str:
+        return SettingsOverride.agent_model(self.id, self.model).value
+
+    def get_effort(self) -> str:
+        harness = get_harness_for_model(self.get_model_name()).name
+        return SettingsOverride.agent_effort(self.id, self.effort, harness).value
+
+    def get_timeout(self) -> int:
+        harness = get_harness_for_model(self.get_model_name()).name
+        resolved = SettingsOverride.agent_timeout(self.id, self.timeout, harness).value
+        # Capped so a single call always fits inside a fresh sandbox lease.
+        return min(resolved, MAX_AGENT_TIMEOUT_SECONDS)
+
+    async def __call__(self, **context: object) -> Any:
+        """Run the agent — ``await Build.implement(...)`` — as a durable step in the
+        current workflow and return its parsed output. An agent run is always memoized —
+        this picks which step does it: its own, or the @step it's already inside.
+        workflow_id comes from the workflow context, not the caller; everything
+        else (repo, …) is prompt context."""
+        workflow = current_workflow.get(None)
+        if not workflow:
+            raise WorkflowError(
+                f"agent {self.id!r} can only run inside a workflow; standalone agent "
+                "runs aren't supported yet"
+            )
+
+        async def _invoke() -> Any:
+            return await self._run(workflow_id=workflow.workflow_id, **context)
+
+        if _in_step.get():
+            return await _invoke()  # the enclosing @step owns the session + memoizes it
+
+        async def _do() -> Any:  # a standalone run is its own memoized step + session
+            async with step_session():
+                return await _invoke()
+
+        return await DBOS.run_step_async(StepOptions(name=f"{workflow.kind}.agent.{self.id}"), _do)
+
+    async def _run(self, *, workflow_id: str, **context: Any) -> Any:
+        """The raw execution: provision or attach a host, record the AgentCall, run
+        the harness. ``run_agent`` handles the durable wrapping + nesting."""
+        if not self.prompt:
+            raise WorkflowError(f"agent {self.id!r} has no prompt template to render")
+        model = self.get_model_name()
+        harness = get_harness_for_model(model)
+        # A run needs a connected harness — refusing here, with the fix in the
+        # message, beats provisioning a VM and 401ing mid-run.
+        harness.get_credentials()
+        workflow = current_workflow.get()
+        # An agent call is a durability boundary — its effects don't roll back —
+        # so commit here rather than hold the step's connection idle through the
+        # minutes of provisioning and the run.
+        db_session().commit()
+        host_id = await workflow._ensure_host()
+        settings = load_settings()
+        artifact_dir = settings.artifacts_dir / f"run-{workflow_id}"
+
+        engine = _step_engine()
+        call_id = harness.mint_run_id(None)
+        await set_run_phase("provisioning_vm")
+
+        # Record the call RUNNING once it has a host to run on (its id names the
+        # on-disk transcript dir) so the live step shows while the agent works,
+        # then finish it — or fail it if the run raised after starting. A
+        # provisioning failure happens before this and records no call.
+        async with _runner(workflow, host_id, workflow_id, self.id) as runner:
+            # Templates read the live workflow + the workspace the agent runs in, alongside
+            # whatever the workflow's get_prompt_context composes.
+            prompt_context = await workflow.get_prompt_context(**context)
+            prompt_context.setdefault("workflow", workflow)
+            prompt_context.setdefault("workspace", runner)
+            prompt = await render_prompt(self.prompt, **prompt_context)
+            await set_run_phase("agent_running")
+            AgentCall.start(
+                engine,
+                call_id=call_id,
+                run_id=workflow_id,
+                model=model,
+                agent=self.id,
+                host_id=runner.host_id,
+            )
+            try:
+                result = await self._execute(runner, model, prompt, artifact_dir, call_id)
+            except BaseException as error:
+                AgentCall.fail(engine, call_id=call_id, error=str(error))
+                raise
+            AgentCall.finish(engine, call_id=call_id, result=result)
+
+        if result.status is AgentCallStatus.FAILED:
+            raise WorkflowError(result.last_error or f"agent {self.id!r} failed")
+
+        output = self.contract.model_validate(result.output)
+        if spec := output.get_artifact():
+            Artifact.record(call_dir=artifact_dir / call_id, call_id=call_id, **spec)
+        return output.to_result()
+
+    async def _execute(
+        self,
+        runner: "Workspace",
+        model: str,
+        prompt: str,
+        artifact_dir: Path,
+        call_id: str,
+    ) -> "AgentResult":
+        schema = self.contract.model_json_schema()
+        return await runner.run_agent(
+            model=model,
+            prompt=prompt,
+            schema=schema,
+            agent=self.id,
+            effort=self.get_effort(),
+            timeout=self.get_timeout(),
+            artifact_dir=artifact_dir,
+            call_id=call_id,
+            include_plugins=self.include_plugins,
+        )

druks-0.0.1/backend/druks/alembic_support.py

@@ -0,0 +1,62 @@
+from alembic import context
+from sqlalchemy import engine_from_config, pool
+
+from druks.models import Base
+from druks.settings import load_settings
+
+
+def _render_item(type_, obj, autogen_context):
+    # The _UtcDateTime decorator only changes read-side tz coercion; its DDL is
+    # plain TIMESTAMPTZ. Render it as such so migrations never import extension code.
+    if type_ == "type" and obj.__class__.__name__ == "_UtcDateTime":
+        return "sa.DateTime(timezone=True)"
+    return False
+
+
+def run_alembic_env(target_metadata=None) -> None:
+    """Run the platform Alembic env against the target metadata. Core and every
+    installed extension share one ``env.py``; the runner selects the scope by setting
+    ``target_metadata`` and ``version_table`` in ``config.attributes``. Metadata
+    falls back to the full ``Base.metadata`` (core's own scope, e.g. core's raw
+    autogenerate). ``include_object`` keeps autogenerate within the scope: a table
+    reflected from the DB but absent from the metadata belongs to another package,
+    so it's never proposed for a drop."""
+    config = context.config
+    if target_metadata is None:
+        target_metadata = config.attributes.get("target_metadata", Base.metadata)
+    if not config.get_main_option("sqlalchemy.url"):
+        config.set_main_option("sqlalchemy.url", load_settings().database_url)
+
+    def include_object(obj, name, type_, reflected, compare_to):
+        if type_ == "table" and reflected and compare_to is None:
+            return name in target_metadata.tables
+        return True
+
+    options = {
+        "target_metadata": target_metadata,
+        "render_item": _render_item,
+        "include_object": include_object,
+        # Each migration history tracks its head in its own version table, so an
+        # installed extension's independent history never reads (and chokes on) core's
+        # revision in the shared default ``alembic_version``.
+        "version_table": config.attributes.get("version_table", "alembic_version"),
+    }
+    if context.is_offline_mode():
+        context.configure(
+            url=config.get_main_option("sqlalchemy.url"),
+            literal_binds=True,
+            dialect_opts={"paramstyle": "named"},
+            **options,
+        )
+        with context.begin_transaction():
+            context.run_migrations()
+        return
+    connectable = engine_from_config(
+        config.get_section(config.config_ini_section, {}),
+        prefix="sqlalchemy.",
+        poolclass=pool.NullPool,
+    )
+    with connectable.connect() as connection:
+        context.configure(connection=connection, **options)
+        with context.begin_transaction():
+            context.run_migrations()