stkit 17.2.1__tar.gz → 17.2.2__tar.gz

{stkit-17.2.1 → stkit-17.2.2}/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Changelog
 
+## v17.2.2 (2026-10-31)
+
+No migration required.
+
+- `stk add-role` and `stk cleanup-sessions` crashed with `TypeError: 'NoneType' object is not callable` because they used the database before the app was built. Every command that runs async work now builds the app first. Run `cleanup-sessions` from cron again if you had stopped it.
+- `stk worker` stops on SIGTERM or Ctrl-C at a safe point: it cancels only the running job, hands it back, and exits without a traceback.
+- The home page describes stk as running on Quart, not Flask.
+- Requires quart-security 2.0.5: login takes the same time whether or not an email has an account, and passkey registration refuses a credential ID another user already holds (Authentication).
+
 ## v17.2.1 (2026-10-31)
 
 No migration required.

{stkit-17.2.1 → stkit-17.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: stkit
-Version: 17.2.1
+Version: 17.2.2
 Summary: An async Quart framework optimized for AI-assisted development workflows
 Project-URL: Documentation, https://docs.stkit.dev
 Project-URL: Source, https://github.com/level09/stk
@@ -28,7 +28,7 @@ Requires-Dist: pillow>=13.0.0
 Requires-Dist: psycopg2-binary>=2.9.10
 Requires-Dist: python-dotenv>=1.2.2
 Requires-Dist: qrcode>=8.2
-Requires-Dist: quart-security<3,>=2.0.4
+Requires-Dist: quart-security<3,>=2.0.5
 Requires-Dist: quart-session>=3.0.0
 Requires-Dist: quart>=0.20.0
 Requires-Dist: rich>=14.0.0

{stkit-17.2.1 → stkit-17.2.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "stkit"
-version = "17.2.1"
+version = "17.2.2"
 description = "An async Quart framework optimized for AI-assisted development workflows"
 authors = [
     {name = "Level09", email = "hello@level09.com"}
@@ -30,7 +30,7 @@ dependencies = [
     "python-dotenv>=1.2.2",
     "qrcode>=8.2",
     "quart>=0.20.0",
-    "quart-security>=2.0.4,<3",
+    "quart-security>=2.0.5,<3",
     "quart-session>=3.0.0",
     "rich>=14.0.0",
     "sqlalchemy[asyncio]>=2.0.41",

{stkit-17.2.1 → stkit-17.2.2}/stk/__init__.py

@@ -3,7 +3,7 @@ stk Framework
 A modern Python web framework optimized for AI-assisted development.
 """
 
-__version__ = "17.2.1"
+__version__ = "17.2.2"
 
 
 def __getattr__(name):

{stkit-17.2.1 → stkit-17.2.2}/stk/cli/base.py

@@ -68,6 +68,9 @@ def cli_app():
 
 def run_async(coro):
     """Run an async function in sync context (for CLI commands)."""
+    # The engine and session factory exist only once the app is built; loading it
+    # here means no command can reach the database without it.
+    cli_app()
 
     async def _wrapper():
         try:

{stkit-17.2.1 → stkit-17.2.2}/stk/cli/develop.py

@@ -1,6 +1,5 @@
 """Starting an app, serving it locally, and running its durable jobs."""
 
-import asyncio
 from pathlib import Path
 
 import click
@@ -82,7 +81,5 @@ def worker(timeout):
             await work(timeout)
 
     console.print("[green]Worker started[/]")
-    try:
-        run_async(run())
-    except (KeyboardInterrupt, asyncio.CancelledError):
-        console.print("Worker stopped")
+    run_async(run())
+    console.print("Worker stopped")

{stkit-17.2.1 → stkit-17.2.2}/stk/tasks/__init__.py

@@ -25,6 +25,7 @@ from stk.tasks.models import Job
 logger = logging.getLogger(__name__)
 
 JOBS = {}
+_running = None  # the job task `stk worker` is awaiting, for a clean shutdown
 TIMEOUT = 3600
 POLL_SECONDS = 2
 RECOVER_SECONDS = 60
@@ -164,8 +165,13 @@ async def run_next(timeout=TIMEOUT):
     job_id, name, payload, attempts, max_attempts = claimed
     async with ext.async_session_factory() as session:
         try:
-            async with asyncio.timeout(timeout):
-                await JOBS[name](session, **payload)
+            global _running
+            _running = asyncio.create_task(JOBS[name](session, **payload))
+            try:
+                # wait_for cancels the job itself on timeout or when this is cancelled.
+                await asyncio.wait_for(_running, timeout)
+            finally:
+                _running = None
             done = await session.execute(
                 _owned(job_id, lease).values(
                     status="done", locked_until=None, last_error=None
@@ -216,11 +222,28 @@ async def recover():
 
 async def work(timeout=TIMEOUT):
     """Run due jobs one at a time until SIGTERM or Ctrl-C."""
-    asyncio.get_running_loop().add_signal_handler(
-        signal.SIGTERM, asyncio.current_task().cancel
-    )
+    stop = asyncio.Event()
+
+    def shutdown():
+        # Cancel only the job, never the worker mid-query: it hands the job back
+        # and the loop ends at its next check.
+        stop.set()
+        if _running is not None:
+            _running.cancel()
+
+    loop = asyncio.get_running_loop()
+    for sig in (signal.SIGTERM, signal.SIGINT):
+        loop.add_signal_handler(sig, shutdown)
+    try:
+        await _drain(timeout, stop)
+    except asyncio.CancelledError:
+        if not stop.is_set():
+            raise
+
+
+async def _drain(timeout, stop):
     recovered = None
-    while True:
+    while not stop.is_set():
         # Also between jobs, so a queue that never empties still recovers.
         if recovered is None or datetime.now() - recovered >= timedelta(
             seconds=RECOVER_SECONDS
@@ -228,4 +251,7 @@ async def work(timeout=TIMEOUT):
             await recover()
             recovered = datetime.now()
         if not await run_next(timeout):
-            await asyncio.sleep(POLL_SECONDS)
+            try:
+                await asyncio.wait_for(stop.wait(), POLL_SECONDS)
+            except TimeoutError:
+                pass

{stkit-17.2.1 → stkit-17.2.2}/stk/templates/index.html

@@ -8,7 +8,7 @@
 
                 <h1 class="text-headline-large font-weight-bold mb-3">Build faster with stk</h1>
                 <p class="text-body-large text-medium-emphasis mb-8">
-                    A modern Flask framework for building web applications.
+                    An async Python framework for building web applications, on Quart.
                 </p>
 
                 {% if current_user.is_authenticated %}

{stkit-17.2.1 → stkit-17.2.2}/tests/test_cli.py

@@ -61,3 +61,20 @@ class DowngradeArgumentTest(unittest.TestCase):
             result = CliRunner().invoke(main, ["db", "downgrade", "-1"])
         self.assertEqual(result.exit_code, 0, result.output)
         self.assertEqual(run.call_args.args[-1], "-1")
+
+
+class DatabaseCommandTest(unittest.TestCase):
+    def test_run_async_builds_the_app_before_touching_the_database(self):
+        """`add-role` and `cleanup-sessions` crashed: nothing had built the engine."""
+        with (
+            patch("stk.cli.base.cli_app") as load,
+            patch("stk.tasks.cleanup_expired_sessions") as cleanup,
+        ):
+            cleanup.side_effect = lambda: _done()
+            result = CliRunner().invoke(main, ["cleanup-sessions"])
+        self.assertEqual(result.exit_code, 0, result.output)
+        load.assert_called()
+
+
+async def _done():
+    return None

{stkit-17.2.1 → stkit-17.2.2}/tests/test_jobs.py

@@ -1,6 +1,8 @@
 """Durable jobs: enqueue, claim, retry, failure, and recovery of a dead worker's job."""
 
 import asyncio
+import os
+import signal
 import unittest
 from datetime import datetime, timedelta
 
@@ -11,7 +13,7 @@ from sqlalchemy import select, update
 import stk.extensions as ext
 from stk.app import Stk
 from stk.settings import TestingConfig
-from stk.tasks import enqueue, job, recover, run_next
+from stk.tasks import enqueue, job, recover, run_next, work
 from stk.tasks.models import Job
 from stk.user.models import Activity, Base, User
 from stk.user.views import api_jobs
@@ -163,6 +165,20 @@ class JobTests(unittest.IsolatedAsyncioTestCase):
         self.assertEqual(row.status, "running")
         self.assertNotIn("lost race", await self.activities())
 
+    async def test_sigterm_hands_back_the_running_job_and_stops_cleanly(self):
+        job_id = await enqueue("jobs_test_slow")
+        worker = asyncio.create_task(work())
+        for _ in range(50):
+            await asyncio.sleep(0.05)
+            if (await self.get(job_id)).status == "running":
+                break
+        os.kill(os.getpid(), signal.SIGTERM)
+        await asyncio.wait_for(worker, 5)  # returns, not CancelledError
+        row = await self.get(job_id)
+        self.assertEqual(
+            (row.status, row.attempts, row.locked_until), ("queued", 0, None)
+        )
+
     async def test_recovers_job_left_running_by_a_dead_worker(self):
         lost = await enqueue("jobs_test_record", user_id=self.user_id, action="lost")
         spent = await enqueue("jobs_test_record", user_id=self.user_id, action="spent")