dirigent-server 0.20.0__tar.gz → 0.22.0__tar.gz

{dirigent_server-0.20.0 → dirigent_server-0.22.0}/PKG-INFO

@@ -1,16 +1,16 @@
 Metadata-Version: 2.4
 Name: dirigent-server
-Version: 0.20.0
+Version: 0.22.0
 Summary: Dirigent FastAPI server: the REST API, its authentication, and the health probes.
 License-Expression: LicenseRef-Proprietary
 License-File: LICENSE
 License-File: THIRD_PARTY_NOTICES.md
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.13
-Requires-Dist: dirigent-client==0.20.0
-Requires-Dist: dirigent-common==0.20.0
-Requires-Dist: dirigent-core==0.20.0
-Requires-Dist: dirigent-examples==0.20.0
+Requires-Dist: dirigent-client==0.22.0
+Requires-Dist: dirigent-common==0.22.0
+Requires-Dist: dirigent-core==0.22.0
+Requires-Dist: dirigent-examples==0.22.0
 Requires-Dist: fastapi>=0.141.1
 Requires-Python: >=3.13
 Description-Content-Type: text/markdown

{dirigent_server-0.20.0 → dirigent_server-0.22.0}/THIRD_PARTY_NOTICES.md

@@ -540,7 +540,7 @@ in the Eclipse Public License, v. 2.0 are satisfied: GNU General Public License
 ## SIL Open Font License 1.1
 
 - `@fontsource-variable/ibm-plex-sans` -- IBM Plex Sans, Copyright 2019 IBM Corp. All rights reserved.
-- `@fontsource/ibm-plex-mono` -- IBM Plex Mono, Copyright 2017 IBM Corp. All rights reserved.
+- `@fontsource/jetbrains-mono` -- JetBrains Mono, Copyright 2020 The JetBrains Mono Project Authors, SIL Open Font License 1.1.
 
 ```
 SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007

{dirigent_server-0.20.0 → dirigent_server-0.22.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "dirigent-server"
-version = "0.20.0"
+version = "0.22.0"
 description = "Dirigent FastAPI server: the REST API, its authentication, and the health probes."
 readme = "README.md"
 requires-python = ">=3.13"
@@ -14,10 +14,10 @@ classifiers = [
     "Programming Language :: Python :: 3.13",
 ]
 dependencies = [
-    "dirigent-client==0.20.0",
-    "dirigent-common==0.20.0",
-    "dirigent-core==0.20.0",
-    "dirigent-examples==0.20.0",
+    "dirigent-client==0.22.0",
+    "dirigent-common==0.22.0",
+    "dirigent-core==0.22.0",
+    "dirigent-examples==0.22.0",
     "fastapi>=0.141.1",
 ]
 

{dirigent_server-0.20.0 → dirigent_server-0.22.0}/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "dirigent-server"
-version = "0.20.0"
+version = "0.22.0"
 description = "Dirigent FastAPI server: the REST API, its authentication, and the health probes."
 readme = "README.md"
 requires-python = ">=3.13"
@@ -11,10 +11,10 @@ classifiers = [
     "Programming Language :: Python :: 3.13",
 ]
 dependencies = [
-    "dirigent-client==0.20.0",
-    "dirigent-common==0.20.0",
-    "dirigent-core==0.20.0",
-    "dirigent-examples==0.20.0",
+    "dirigent-client==0.22.0",
+    "dirigent-common==0.22.0",
+    "dirigent-core==0.22.0",
+    "dirigent-examples==0.22.0",
     "fastapi>=0.141.1",
 ]
 

{dirigent_server-0.20.0 → dirigent_server-0.22.0}/src/dirigent_server/app.py

@@ -7,7 +7,7 @@ from contextlib import asynccontextmanager
 
 from fastapi import FastAPI
 
-from dirigent_core import __version__
+from dirigent_core import __version__, wakeups
 from dirigent_core.auth import BOOTSTRAP_PASSWORD_ENV, bootstrap_admin
 from dirigent_core.config import Settings, get_settings
 from dirigent_core.database import create_engine, create_session_factory, session_scope
@@ -73,16 +73,17 @@ def create_app(
         app.state.scheduler = None
         clock: asyncio.Task[None] | None = None
         try:
-            await _bootstrap(app)
-            await _apply_startup_directory(app)
-            clock = await _start_scheduler(app, embed=embed)
-            _logger.info(
-                "server starting",
-                database="sqlite" if resolved.is_sqlite else "postgresql",
-                blocks=len(app.state.services.host.block_ids),
-                scheduler=embed,
-            )
-            yield
+            async with wakeups.listening(resolved.database_url):
+                await _bootstrap(app)
+                await _apply_startup_directory(app)
+                clock = await _start_scheduler(app, embed=embed)
+                _logger.info(
+                    "server starting",
+                    database="sqlite" if resolved.is_sqlite else "postgresql",
+                    blocks=len(app.state.services.host.block_ids),
+                    scheduler=embed,
+                )
+                yield
         finally:
             await _stop_scheduler(app, clock)
             await engine.dispose()

{dirigent_server-0.20.0 → dirigent_server-0.22.0}/src/dirigent_server/health.py

@@ -9,6 +9,7 @@ from fastapi import APIRouter, Request, Response, status
 from sqlalchemy.ext.asyncio import AsyncEngine
 
 from dirigent_client.schemas import CheckResult, CheckStatus, Health, Readiness
+from dirigent_common import raised_detail
 from dirigent_core.database import ping
 
 router = APIRouter(tags=["health"])
@@ -73,7 +74,7 @@ async def run_checks(registry: HealthCheckRegistry) -> dict[str, CheckResult]:
         try:
             return await check.check()
         except Exception as error:
-            return CheckResult(status=CheckStatus.UNHEALTHY, detail=f"{type(error).__name__}: {error}")
+            return CheckResult(status=CheckStatus.UNHEALTHY, detail=raised_detail(error))
 
     names = list(registry)
     results = await asyncio.gather(*(run(registry[name]) for name in names))

{dirigent_server-0.20.0 → dirigent_server-0.22.0}/src/dirigent_server/routes/__init__.py

@@ -15,6 +15,7 @@ from dirigent_server.routes import (
     connections,
     examples,
     hooks,
+    labels,
     pipelines,
     playground,
     runs,
@@ -38,6 +39,7 @@ TAGS: list[dict[str, str]] = [
     {"name": "hooks", "description": "Webhook intake, authenticated by its own token."},
     {"name": "connections", "description": "Named credential records of contributed kinds."},
     {"name": "blocks", "description": "The catalog every plugin contributes to."},
+    {"name": "labels", "description": "The wording every installed pack refuses in."},
     {"name": "examples", "description": "The documents every installed plugin ships."},
     {"name": "schema", "description": "The shape a document is written against."},
     {"name": "schemas", "description": "Named JSON Schemas the instance holds."},
@@ -72,6 +74,7 @@ def build_router(settings: Settings | None = None) -> APIRouter:
         alerts,
         connections,
         blocks,
+        labels,
         examples,
         schema,
         schemas,

dirigent_server-0.22.0/src/dirigent_server/routes/labels.py

@@ -0,0 +1,16 @@
+"""The wording every installed pack refuses in, for a surface that renders its own sentences."""
+
+from fastapi import APIRouter
+
+from dirigent_client.schemas import Labels
+from dirigent_server.dependencies import ServicesDep
+from dirigent_server.security import PrincipalDep
+from dirigent_server.transactions import Transactional
+
+router = APIRouter(route_class=Transactional, tags=["labels"])
+
+
+@router.get("/labels", operation_id="getLabels", summary="Contributed refusal wording", response_model=Labels)
+async def get_labels(services: ServicesDep, principal: PrincipalDep) -> Labels:
+    """Serve every code an installed pack can refuse under, with the template it renders from."""
+    return Labels(templates={code: message.text for code, message in services.host.labels.items()})

{dirigent_server-0.20.0 → dirigent_server-0.22.0}/src/dirigent_server/routes/pipelines.py

@@ -28,6 +28,7 @@ from dirigent_core.documents import carried_refusal, load_document
 from dirigent_core.engine import Attribution, create_run
 from dirigent_core.engine.definition import load_definition
 from dirigent_core.engine.runs import Provenance, RunWindow
+from dirigent_core.engine.services import EngineServices
 from dirigent_core.messages import PIPELINE_DEACTIVATED, PIPELINE_NO_VERSIONS
 from dirigent_core.models import Pipeline
 from dirigent_core.pipelines import (
@@ -64,6 +65,7 @@ def render(row: Pipeline, counts: PipelineCounts = NO_COUNTS, last: LastRun | No
             "active_runs": counts.active_runs,
             "schedules": counts.schedules,
             "webhooks": counts.webhooks,
+            "watches": counts.watches,
             "last_run": last,
         }
     )
@@ -113,7 +115,7 @@ async def apply(
 ) -> ApplyResult:
     """Validate a document against this instance and commit a new version, or plan one.
 
-    ``pause_schedules`` on the request creates this apply's new schedules paused; one the
+    ``pause_schedules`` on the request creates this apply's new schedules and watches paused; one the
     instance already holds keeps the paused state it has.
     """
     raw = dict(payload.document)
@@ -147,6 +149,7 @@ async def apply(
 async def prune(
     payload: PruneRequest,
     session: SessionDep,
+    services: ServicesDep,
     principal: OperatorDep,
     dry_run: Annotated[bool, Query(description="Report what would be deactivated without writing.")] = False,
 ) -> PruneResult:
@@ -160,7 +163,7 @@ async def prune(
     """
     if not payload.keep and not dry_run:
         raise Refusal(PRUNE_NAMES_NOTHING, status=status.HTTP_422_UNPROCESSABLE_CONTENT)
-    return await prune_absent(session, set(payload.keep), dry_run=dry_run)
+    return await prune_absent(session, services, set(payload.keep), dry_run=dry_run)
 
 
 @router.get(
@@ -243,9 +246,9 @@ async def validate_stored(
     summary="Activate a pipeline",
     response_model=PipelineOut,
 )
-async def activate(code: str, session: SessionDep, principal: OperatorDep) -> PipelineOut:
-    """Make a pipeline runnable again, and let its schedules fire."""
-    return render(await _act(session, code, active=True))
+async def activate(code: str, session: SessionDep, services: ServicesDep, principal: OperatorDep) -> PipelineOut:
+    """Make a pipeline runnable again, let its schedules fire, and arm its watches."""
+    return render(await _act(session, services, code, active=True))
 
 
 @router.post(
@@ -254,9 +257,9 @@ async def activate(code: str, session: SessionDep, principal: OperatorDep) -> Pi
     summary="Deactivate a pipeline",
     response_model=PipelineOut,
 )
-async def deactivate(code: str, session: SessionDep, principal: OperatorDep) -> PipelineOut:
-    """Deregister a pipeline: schedules pause, it stops being runnable, history is kept."""
-    return render(await _act(session, code, active=False))
+async def deactivate(code: str, session: SessionDep, services: ServicesDep, principal: OperatorDep) -> PipelineOut:
+    """Deregister a pipeline: schedules pause, watches stop waiting, it stops being runnable, history is kept."""
+    return render(await _act(session, services, code, active=False))
 
 
 @router.delete(
@@ -265,15 +268,16 @@ async def deactivate(code: str, session: SessionDep, principal: OperatorDep) ->
     summary="Delete a pipeline and its history",
     status_code=status.HTTP_204_NO_CONTENT,
 )
-async def delete(code: str, session: SessionDep, principal: AdminDep) -> Response:
+async def delete(code: str, session: SessionDep, services: ServicesDep, principal: AdminDep) -> Response:
     """Delete a pipeline and every run ever attributed to it, in one transaction.
 
     Admin, unlike every other pipeline verb, and it takes the history with it: the runs,
-    their items, attempts, logs and artifact references, plus the versions, schedules and
-    webhooks the definition owns. Runs still in flight refuse the delete with a 409 --
+    their items, attempts, logs and artifact references, plus the versions, schedules,
+    webhooks and watches the definition owns. The run a watch has waiting is cancelled; any
+    other run still in flight refuses the delete with a 409 --
     finish or cancel them first. Deactivating is the reversible verb an operator has.
     """
-    await delete_pipeline(session, code)
+    await delete_pipeline(session, services, code)
     return Response(status_code=status.HTTP_204_NO_CONTENT)
 
 
@@ -388,6 +392,6 @@ async def _require(session: AsyncSession, code: str) -> Pipeline:
     return await require_pipeline(session, code)
 
 
-async def _act(session: AsyncSession, code: str, *, active: bool) -> Pipeline:
+async def _act(session: AsyncSession, services: EngineServices, code: str, *, active: bool) -> Pipeline:
     """Activate or deactivate, which refuses an unknown code as a 404 of its own."""
-    return await set_active(session, code, active=active)
+    return await set_active(session, services, code, active=active)

{dirigent_server-0.20.0 → dirigent_server-0.22.0}/src/dirigent_server/routes/runs.py

@@ -1,6 +1,7 @@
 """Runs: the list, the detail with its DAG view model, cancellation, retry, logs, events, and a report."""
 
 import asyncio
+import time
 from collections.abc import AsyncGenerator, Generator, Mapping, Sequence
 from contextlib import contextmanager
 from datetime import UTC, datetime, timedelta
@@ -12,7 +13,7 @@ from fastapi import APIRouter, Header, Query, Request, Response, status
 from fastapi.responses import PlainTextResponse, StreamingResponse
 from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker
 
-from dirigent_client.enums import AttemptStatus, LogLevel, RunItemStatus, RunStatus
+from dirigent_client.enums import AttemptStatus, LogLevel, RunItemStatus, RunStatus, TriggerKind
 from dirigent_client.schemas import (
     TERMINAL_RUN_STATUSES,
     ArtifactOut,
@@ -29,12 +30,13 @@ from dirigent_client.schemas import (
     StepReport,
 )
 from dirigent_common.durations import DurationError, parse_duration
-from dirigent_core import telemetry
+from dirigent_core import telemetry, wakeups
 from dirigent_core.artifacts import JSON_CONTENT_TYPE, TEXT_KEY, canonical_json, open_artifact
 from dirigent_core.database import session_scope
 from dirigent_core.engine.definition import PipelineDefinition, load_definition
 from dirigent_core.engine.runs import cancel_run, retry_step
 from dirigent_core.engine.state import StepCounts, attempt_counts, item_counts, step_states
+from dirigent_core.messages import CANCELLED_BY
 from dirigent_core.models import (
     ArtifactRef,
     LogEntry,
@@ -63,7 +65,7 @@ from dirigent_server.messages import (
 )
 from dirigent_server.pagination import DEFAULT_PAGE, AfterParam, LimitParam, clip, int_cursor, uuid_cursor
 from dirigent_server.security import OperatorDep, PrincipalDep
-from dirigent_server.transactions import Transactional
+from dirigent_server.transactions import Transactional, retried_on_deadlock
 
 router = APIRouter(route_class=Transactional, tags=["runs"])
 
@@ -119,10 +121,12 @@ def _render_run(run: Run, pipeline: Pipeline, version: PipelineVersion, failed:
         priority=run.priority,
         params=dict(run.params),
         triggered_by_kind=run.triggered_by_kind,
+        parent_run_id=run.triggered_by_id if run.triggered_by_kind is TriggerKind.PIPELINE else None,
         triggered_by_label=run.triggered_by_label,
         trace_id=telemetry.trace_id_of(run.traceparent),
         error=run.error or (failed.error if failed is not None else None),
         error_code=run.error_code or (failed.code if failed is not None else None),
+        error_params=run.error_params or (failed.params if failed is not None else None),
         failed_step=failed.step if failed is not None else None,
         started_at=run.started_at,
         finished_at=run.finished_at,
@@ -161,6 +165,7 @@ def _dag(
                 depends_on=list(step.depends_on),
                 rule=step.rule.value,
                 fan_out=step.is_fan_out,
+                grid_source=definition.grid_source(name),
                 items_total=sum(of_step.values()),
                 items_failed=of_step.get(RunItemStatus.FAILED, 0),
                 attempts=attempts[name].total if name in attempts else 0,
@@ -383,10 +388,14 @@ def _render_attempt(attempt: StepAttempt, spilled: dict[UUID, tuple[str, int | N
 @router.post("/runs/{run_id}/$cancel", operation_id="cancelRun", summary="Cancel a run", response_model=RunOut)
 async def cancel(run_id: UUID, session: SessionDep, services: ServicesDep, principal: OperatorDep) -> RunOut:
     """Stop what has not started, and tell the remote about what has."""
-    run = await _run_row(session, run_id)
-    pipeline, version, _ = await _context(session, run)
-    await cancel_run(session, services, run, reason=f"cancelled by {principal.label}")
-    return _render_run(run, pipeline, version)
+
+    async def cancel_once() -> RunOut:
+        run = await _run_row(session, run_id)
+        pipeline, version, _ = await _context(session, run)
+        await cancel_run(session, services, run, CANCELLED_BY, principal=principal.label)
+        return _render_run(run, pipeline, version)
+
+    return await retried_on_deadlock(session, cancel_once)
 
 
 @router.post(
@@ -480,6 +489,19 @@ def next_interval(current: float) -> float:
     return min(current * FOLLOW_BACKOFF, FOLLOW_MAX_INTERVAL_SECONDS)
 
 
+async def quiet_wait(mark: wakeups.Mark, waited: float, interval: float) -> tuple[float, float]:
+    """Wait out one quiet interval, or less when the run moves, and say how long and what next.
+
+    A run that moved sends the stream back to its shortest interval.
+    """
+    started = time.monotonic()
+    moved = await wakeups.wait_settled(mark, timeout=interval)
+    elapsed = time.monotonic() - started
+    if moved:
+        return waited + elapsed, FOLLOW_INTERVAL_SECONDS
+    return waited + elapsed, next_interval(interval)
+
+
 def _claim(user_id: UUID) -> str:
     """Name the principal a stream is opened by, refusing one that already holds the cap.
 
@@ -547,6 +569,7 @@ async def _tail(
         waited = 0.0
         interval = FOLLOW_INTERVAL_SECONDS
         while waited < FOLLOW_MAX_SECONDS:
+            moved = wakeups.settled_mark(run_id)
             page, settled = await asyncio.shield(_tail_read(sessions, run_id, cursor, step))
             for entry in page.items:
                 yield f"id: {entry.id}\nevent: log\ndata: {entry.model_dump_json()}\n\n"
@@ -557,9 +580,7 @@ async def _tail(
             if settled:
                 yield "event: end\ndata: {}\n\n"
                 return
-            await asyncio.sleep(interval)
-            waited += interval
-            interval = next_interval(interval)
+            waited, interval = await quiet_wait(moved, waited, interval)
         yield "event: expired\ndata: {}\n\n"
 
 
@@ -735,6 +756,7 @@ async def _story(
         waited = 0.0
         interval = FOLLOW_INTERVAL_SECONDS
         while waited < FOLLOW_MAX_SECONDS:
+            changed = wakeups.settled_mark(run_id)
             # Shielded for the same reason _tail_read is: a disconnect lands between polls,
             # never inside a driver await holding the pooled connection.
             attempts, spilled, page, rendered, read_labels = await asyncio.shield(
@@ -778,9 +800,7 @@ async def _story(
                     return
                 drained = True
                 continue
-            await asyncio.sleep(interval)
-            waited += interval
-            interval = next_interval(interval)
+            waited, interval = await quiet_wait(changed, waited, interval)
         yield "event: expired\ndata: {}\n\n"
 
 
@@ -814,10 +834,14 @@ async def report(run_id: UUID, session: SessionDep, principal: PrincipalDep) ->
                 warnings=step.warnings,
                 duration_ms=step.duration_ms,
                 error=step.error,
+                error_code=step.error_code,
+                error_params=step.error_params,
             )
             for step in facts.steps
         ],
         items_total=facts.items_total,
         items_failed=facts.items_failed,
         error=run.error,
+        error_code=run.error_code,
+        error_params=run.error_params,
     )

{dirigent_server-0.20.0 → dirigent_server-0.22.0}/src/dirigent_server/routes/trigger_documents.py

@@ -1,4 +1,4 @@
-"""Triggers documents: the clocks and webhooks one document declares for another's pipeline.
+"""Triggers documents: the clocks, webhooks and watches one document declares for another's pipeline.
 
 A document is applied through ``POST /pipelines/$apply`` like any other; what is here is
 reading the ones the instance holds, and removing one with the rows it owns.
@@ -16,7 +16,7 @@ from dirigent_core.trigger_documents import (
     list_trigger_documents,
     owned_codes,
 )
-from dirigent_server.dependencies import SessionDep
+from dirigent_server.dependencies import ServicesDep, SessionDep
 from dirigent_server.errors import Refusal
 from dirigent_server.messages import NO_TRIGGER_DOCUMENT
 from dirigent_server.pagination import DEFAULT_PAGE, AfterParam, LimitParam, clip
@@ -71,13 +71,14 @@ async def list_all(
 async def get_one(code: str, session: SessionDep, principal: PrincipalDep) -> TriggerDocumentDetail:
     """Read one triggers document, the document itself, and the rows it owns."""
     row = await _require(session, code)
-    schedules, webhooks = await owned_codes(session, row.id)
+    schedules, webhooks, watches = await owned_codes(session, row.id)
     base = render(row, await _pipeline_code(session, row))
     return TriggerDocumentDetail(
         **base.model_dump(),
         document=dict(row.document),
         schedules=schedules,
         webhooks=webhooks,
+        watches=watches,
     )
 
 
@@ -87,13 +88,13 @@ async def get_one(code: str, session: SessionDep, principal: PrincipalDep) -> Tr
     summary="Delete a triggers document and its rows",
     status_code=status.HTTP_204_NO_CONTENT,
 )
-async def delete(code: str, session: SessionDep, principal: OperatorDep) -> Response:
-    """Remove a triggers document, and with it every schedule and webhook it declared.
+async def delete(code: str, session: SessionDep, services: ServicesDep, principal: OperatorDep) -> Response:
+    """Remove a triggers document, and with it every schedule, webhook and watch it declared.
 
     The pipeline it named is untouched, and so is anything the pipeline's own document or an
     operator declared on it.
     """
-    await delete_trigger_document(session, await _require(session, code))
+    await delete_trigger_document(session, services, await _require(session, code))
     return Response(status_code=status.HTTP_204_NO_CONTENT)
 
 

{dirigent_server-0.20.0 → dirigent_server-0.22.0}/src/dirigent_server/routes/triggers.py

@@ -1,4 +1,4 @@
-"""A pipeline's persisted triggers: its schedules and its inbound webhooks.
+"""A pipeline's persisted triggers: its schedules, its inbound webhooks, and its watches.
 
 The instance keeps only the hash of a webhook's token, so the token is readable exactly
 once: when it is minted or rotated.
@@ -22,6 +22,7 @@ from dirigent_client.schemas import (
     ScheduleOut,
     SchedulePreview,
     SchedulePreviewRequest,
+    WatchOut,
     WebhookIn,
     WebhookOut,
     WebhookTokenOut,
@@ -34,6 +35,7 @@ from dirigent_core.models import (
     Schedule,
     ScheduleFiring,
     TriggerDocument,
+    Watch,
     WebhookDelivery,
     WebhookTrigger,
 )
@@ -41,6 +43,7 @@ from dirigent_core.pipelines import get_version, require_pipeline
 from dirigent_core.triggers import (
     ScheduleRequest,
     UnknownSchedule,
+    UnknownWatch,
     UnknownWebhook,
     WebhookRequest,
     check_schedule_params,
@@ -50,21 +53,24 @@ from dirigent_core.triggers import (
     delete_schedule,
     delete_webhook,
     find_schedule,
+    find_watch,
     find_webhook,
     list_deliveries,
     list_firings,
     list_schedules,
+    list_watches,
     list_webhooks,
     preview_firings,
     rotate_token,
     set_active,
     set_paused,
+    set_watch_paused,
     update_schedule,
 )
 from dirigent_server.dependencies import ServicesDep, SessionDep
 from dirigent_server.pagination import DEFAULT_PAGE, AfterParam, LimitParam, clip, int_cursor
 from dirigent_server.security import OperatorDep, PrincipalDep
-from dirigent_server.transactions import Transactional
+from dirigent_server.transactions import Transactional, retried_on_deadlock
 
 router = APIRouter(route_class=Transactional, tags=["triggers"])
 
@@ -101,7 +107,7 @@ def _webhook_request(payload: WebhookIn) -> WebhookRequest:
     )
 
 
-async def owning_documents(session: AsyncSession, rows: Sequence[Schedule | WebhookTrigger]) -> dict[UUID, str]:
+async def owning_documents(session: AsyncSession, rows: Sequence[Schedule | WebhookTrigger | Watch]) -> dict[UUID, str]:
     """Read the code of every triggers document that owns one of these rows."""
     wanted = {row.trigger_document_id for row in rows if row.trigger_document_id is not None}
     if not wanted:
@@ -158,6 +164,29 @@ def render_webhook(row: WebhookTrigger, documents: Mapping[UUID, str] = MappingP
     )
 
 
+def render_watch(row: Watch, documents: Mapping[UUID, str] = MappingProxyType({})) -> WatchOut:
+    """Render a watch row: what it waits on, where it left off, and how its waits are going."""
+    return WatchOut(
+        id=row.id,
+        code=row.code,
+        name=row.name,
+        description=row.description,
+        step=row.step,
+        params=dict(row.params),
+        paused=row.paused,
+        managed=row.managed,
+        trigger_document=documents.get(row.trigger_document_id) if row.trigger_document_id else None,
+        cursor=dict(row.cursor) if row.cursor is not None else None,
+        waiting_run_id=row.waiting_run_id,
+        failures=row.failures,
+        last_error=row.last_error,
+        last_error_at=row.last_error_at,
+        rearm_at=row.rearm_at,
+        last_armed_at=row.last_armed_at,
+        created_at=row.created_at,
+    )
+
+
 async def _schedule_out(session: AsyncSession, row: Schedule) -> ScheduleOut:
     """Render one schedule, with the code of whichever triggers document owns it."""
     return render_schedule(row, await owning_documents(session, [row]))
@@ -463,6 +492,79 @@ async def remove_webhook(code: str, webhook: str, session: SessionDep, principal
     return Response(status_code=status.HTTP_204_NO_CONTENT)
 
 
+@router.get(
+    "/pipelines/{code}/triggers/watches",
+    operation_id="listWatches",
+    summary="List a pipeline's watches",
+    response_model=Page[WatchOut],
+)
+async def watches(
+    code: str,
+    session: SessionDep,
+    principal: PrincipalDep,
+    after: AfterParam = None,
+    limit: LimitParam = DEFAULT_PAGE,
+) -> Page[WatchOut]:
+    """List every watch on a pipeline, with the run each one has waiting."""
+    pipeline = await _require(session, code)
+    rows = await list_watches(session, pipeline.id, after=after, limit=limit + 1)
+    documents = await owning_documents(session, rows)
+    items, following = clip([render_watch(row, documents) for row in rows], limit, lambda row: row.code)
+    return Page(items=items, next=following)
+
+
+@router.get(
+    "/pipelines/{code}/triggers/watches/{watch}",
+    operation_id="getWatch",
+    summary="Read one watch",
+    response_model=WatchOut,
+)
+async def get_watch(code: str, watch: str, session: SessionDep, principal: PrincipalDep) -> WatchOut:
+    """Read one watch by code."""
+    return await _watch_out(session, await _require_watch(session, code, watch))
+
+
+@router.post(
+    "/pipelines/{code}/triggers/watches/{watch}/$pause",
+    operation_id="pauseWatch",
+    summary="Pause a watch",
+    response_model=WatchOut,
+)
+async def pause_watch(
+    code: str, watch: str, session: SessionDep, services: ServicesDep, principal: OperatorDep
+) -> WatchOut:
+    """Stop a watch, cancelling the run it has waiting, and keep where it left off."""
+
+    async def pause_once() -> WatchOut:
+        row = await _require_watch(session, code, watch)
+        return await _watch_out(session, await set_watch_paused(session, services, row, paused=True))
+
+    return await retried_on_deadlock(session, pause_once)
+
+
+@router.post(
+    "/pipelines/{code}/triggers/watches/{watch}/$resume",
+    operation_id="resumeWatch",
+    summary="Resume a watch",
+    response_model=WatchOut,
+)
+async def resume_watch(
+    code: str, watch: str, session: SessionDep, services: ServicesDep, principal: OperatorDep
+) -> WatchOut:
+    """Start a watch again, arming a run from where its last success left off."""
+
+    async def resume_once() -> WatchOut:
+        row = await _require_watch(session, code, watch)
+        return await _watch_out(session, await set_watch_paused(session, services, row, paused=False))
+
+    return await retried_on_deadlock(session, resume_once)
+
+
+async def _watch_out(session: AsyncSession, row: Watch) -> WatchOut:
+    """Render one watch, with the code of whichever triggers document owns it."""
+    return render_watch(row, await owning_documents(session, [row]))
+
+
 async def _check_pins(session: AsyncSession, services: EngineServices, pipeline_id: UUID, payload: ScheduleIn) -> None:
     """Check a schedule's pinned parameters against the definition its firings will run.
 
@@ -501,6 +603,15 @@ async def _require_schedule(session: AsyncSession, pipeline_code: str, code: str
     return schedule
 
 
+async def _require_watch(session: AsyncSession, pipeline_code: str, code: str) -> Watch:
+    """Read one watch within its pipeline, or say which half was not found."""
+    pipeline = await _require(session, pipeline_code)
+    watch = await find_watch(session, pipeline.id, code)
+    if watch is None:
+        raise UnknownWatch(pipeline_code, code)
+    return watch
+
+
 async def _require_webhook(session: AsyncSession, pipeline_code: str, code: str) -> WebhookTrigger:
     """Read one webhook within its pipeline, or say which half was not found."""
     pipeline = await _require(session, pipeline_code)

dirigent_server-0.22.0/src/dirigent_server/static/assets/AdminOnly-Di7pCILM.js

@@ -0,0 +1 @@
+import{t as e}from"./labels-D4COsPsJ.js";import{n as t}from"./PageState-Dqk77uol.js";import{r as n}from"./utils-CT7ZGLfR.js";import{t as r}from"./use-store-CZcp6jmY.js";import{n as i,t as a}from"./auth-DdhSYe4e.js";var o=n(),s={status:403,title:e.refusal.admin_only,code:`server.forbidden`,params:{},detail:e.refusal.shut,problems:[],instance:null};function c({children:e}){let n=r(a);return i(n)?(0,o.jsx)(o.Fragment,{children:e}):(0,o.jsx)(t,{loading:!1,problem:s,empty:!1,children:null})}export{c as t};