ok-script 2.0.20__tar.gz → 2.0.21__tar.gz

{ok_script-2.0.20 → ok_script-2.0.21}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ok-script
-Version: 2.0.20
+Version: 2.0.21
 Summary: Automation with Computer Vision for Python
 Author-email: ok-oldking <firedcto@gmail.com>
 License: ok-script License

{ok_script-2.0.20 → ok_script-2.0.21}/docs/mcp.md

@@ -72,6 +72,15 @@ Applications using `OK(config).start()` can enable MCP through their config:
 "mcp": {"enabled": True, "port": 8765, "artifact_directory": "logs/mcp"}
 ```
 
+MCP artifacts use a seven-day retention period by default. Set `mcp.retention_days`
+to a nonnegative number of days, or `0` to disable cleanup. Cleanup runs on startup
+and at most once per hour when submitting runs/reloads or requesting screenshots.
+It removes expired completed run directories (including their logs, status and
+custom artifacts), their in-memory status records, and old observation images.
+Run age is measured from `finished_at`; observation age uses the image file's
+modification time. Active/nonterminal runs, unrecognized files and connection
+records are preserved. Copy evidence elsewhere if it must outlive retention.
+
 The server binds only to IPv4 loopback and validates HTTP Host and Origin.
 Each instance writes `logs/mcp/connections/<pid>-<port>.json` containing its URL,
 bearer token, process ID, process start time and project directory. These records
@@ -143,7 +152,7 @@ Clients supporting MCP resources can also discover these skills through
 
 States are `queued`, `running`, `stopping`, `succeeded`, `failed`, and
 `cancelled`. Only the last three are terminal. Run IDs are scoped to the current
-process; saved artifacts remain available after restarting it.
+process; saved artifacts remain available after restarting it until retention cleanup.
 
 ## Preferred workflow for existing tasks
 

{ok_script-2.0.20 → ok_script-2.0.21}/ok/core/code_runner.py

@@ -24,7 +24,7 @@ from typing import Any
 
 from ok.task.exceptions import TaskDisabledException
 
-_log_formatter = logging.Formatter('%(asctime)s %(levelname)s %(message)s', datefmt='%H:%M:%S')
+_log_formatter = logging.Formatter('%(asctime)s.%(msecs)03d %(levelname)s %(message)s', datefmt='%H:%M:%S')
 _capture_lock = threading.Lock()
 _run_ids = itertools.count(1)
 

{ok_script-2.0.20 → ok_script-2.0.21}/ok/core/mcp_runner.py

@@ -4,6 +4,9 @@ import hashlib
 import importlib.util
 import inspect
 import json
+import math
+import re
+import shutil
 import sys
 import threading
 import time
@@ -15,9 +18,11 @@ from pathlib import Path
 from ok.core.code_runner import capture_output
 from ok.task.exceptions import TaskDisabledException
 from ok.task.task import BaseTask, TriggerTask
+from ok.util.logger import Logger
 
 
 TERMINAL_STATES = {'succeeded', 'failed', 'cancelled'}
+logger = Logger.get_logger(__name__)
 
 
 class McpTaskRunner:
@@ -30,7 +35,10 @@ class McpTaskRunner:
     """
 
     def __init__(self, executor, app, screenshot_service, artifact_directory='logs/mcp', prepare=None,
-                 task_manager=None):
+                 task_manager=None, retention_days=7):
+        if (isinstance(retention_days, bool) or not isinstance(retention_days, (int, float))
+                or not math.isfinite(retention_days) or retention_days < 0):
+            raise ValueError('mcp.retention_days must be a finite nonnegative number')
         self.executor = executor
         self.app = app
         self.screenshot_service = screenshot_service
@@ -42,8 +50,63 @@ class McpTaskRunner:
         self._active = None
         self._observation_job = None
         self._closed = False
+        self.retention_days = retention_days
+        self._next_cleanup = 0
+        self._cleanup_artifacts()
         self.executor.enable_frame_snapshots()
 
+    def _cleanup_artifacts(self):
+        """Expire completed runs and observations, at most hourly during activity."""
+        with self._lock:
+            now = time.monotonic()
+            if self.retention_days == 0 or now < self._next_cleanup:
+                return
+            self._next_cleanup = now + 3600
+            cutoff = time.time() - self.retention_days * 86400
+            try:
+                paths = list(self.artifact_directory.iterdir())
+            except FileNotFoundError:
+                return
+            except OSError as error:
+                logger.warning(f'Could not scan MCP artifacts: {error}')
+                return
+            for path in paths:
+                try:
+                    # Only operate on framework-owned entries inside this root.
+                    # In particular, never follow directory links or junctions.
+                    if path.is_symlink() or path.resolve() != path:
+                        continue
+                    if path.name == 'observations' and path.is_dir():
+                        for image in path.iterdir():
+                            if (re.fullmatch(r'[0-9a-f]{32}\.png', image.name)
+                                    and not image.is_symlink() and image.is_file()
+                                    and image.resolve() == image
+                                    and image.stat().st_mtime < cutoff):
+                                try:
+                                    image.unlink()
+                                except OSError as error:
+                                    logger.warning(f'Could not remove MCP observation {image}: {error}')
+                    elif (re.fullmatch(r'[0-9a-f]{32}', path.name) and path.is_dir()
+                          and path.name != self._active):
+                        try:
+                            record = json.loads((path / 'status.json').read_text(encoding='utf-8'))
+                        except (ValueError, UnicodeError):
+                            continue
+                        if not isinstance(record, dict):
+                            continue
+                        finished = record.get('finished_at')
+                        if (record.get('run_id') == path.name
+                                and isinstance(record.get('state'), str)
+                                and record['state'] in TERMINAL_STATES
+                                and isinstance(finished, (int, float)) and not isinstance(finished, bool)
+                                and math.isfinite(finished) and finished < cutoff):
+                            shutil.rmtree(path)
+                            self._runs.pop(path.name, None)
+                except FileNotFoundError:
+                    pass  # Another server sharing this directory may have removed it.
+                except OSError as error:
+                    logger.warning(f'Could not clean MCP artifacts {path}: {error}')
+
     def _save(self, record):
         path = Path(record['artifact_directory']) / 'status.json'
         temporary = path.with_suffix('.tmp')
@@ -135,6 +198,7 @@ class McpTaskRunner:
                 raise RuntimeError('MCP task runner is shutting down')
             if self._active is not None:
                 raise RuntimeError(f'Run {self._active} is still active; wait until it has stopped')
+            self._cleanup_artifacts()
             run_id = uuid.uuid4().hex
             owner = f'mcp:{run_id}'
             self.executor.acquire_exclusive(owner)
@@ -282,6 +346,7 @@ class McpTaskRunner:
         with self._lock:
             if self._closed:
                 raise RuntimeError('MCP task runner is shutting down')
+            self._cleanup_artifacts()
             if (self._active is None and self._observation_job is None and self.executor.current_job is None
                     and self.executor.current_task is None and self.executor.exclusive_owner is None):
                 def capture():

{ok_script-2.0.20 → ok_script-2.0.21}/ok/core/mcp_server.py

@@ -232,7 +232,7 @@ class LocalMcpServer:
         app = runtime.headless_app if runtime.should_init_task_manager_headless() else runtime.app
         self.runner = McpTaskRunner(runtime.task_executor, app, runtime.screenshot,
                                     config.get('artifact_directory', 'logs/mcp'), self._prepare_device,
-                                    task_manager=og.task_manager)
+                                    task_manager=og.task_manager, retention_days=config.get('retention_days', 7))
         self._server = None
         self._socket = None
         self._thread = None
@@ -289,9 +289,11 @@ class LocalMcpServer:
             self.port = self._socket.getsockname()[1]
             app = create_mcp_app(self.runner, self.token, self.port, self.exit_process)
             import uvicorn
+            # uvicorn's default log_config goes through dictConfig, which closes every
+            # existing handler in the process, including the ok-script.log file handler.
             self._server = uvicorn.Server(uvicorn.Config(
                 app, host='127.0.0.1', port=self.port, log_level='warning', access_log=False,
-                timeout_graceful_shutdown=5))
+                log_config=None, timeout_graceful_shutdown=5))
 
             def serve():
                 try:

{ok_script-2.0.20 → ok_script-2.0.21}/ok_script.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ok-script
-Version: 2.0.20
+Version: 2.0.21
 Summary: Automation with Computer Vision for Python
 Author-email: ok-oldking <firedcto@gmail.com>
 License: ok-script License

{ok_script-2.0.20 → ok_script-2.0.21}/ok_script.egg-info/SOURCES.txt

@@ -349,6 +349,7 @@ tests/test_logger.py
 tests/test_main_window_notifications.py
 tests/test_main_window_startup_tab.py
 tests/test_main_window_system_theme.py
+tests/test_mcp_cleanup.py
 tests/test_mcp_runner.py
 tests/test_mcp_server.py
 tests/test_mcp_setting.py

ok_script-2.0.21/tests/test_mcp_cleanup.py

@@ -0,0 +1,166 @@
+import json
+import os
+import time
+import uuid
+from pathlib import Path
+from unittest.mock import Mock
+
+import pytest
+
+from ok.core.mcp_runner import McpTaskRunner
+from test_mcp_runner import development, wait_run, write_task
+
+
+def saved_run(root, *, state='succeeded', age=8, **fields):
+    path = root / uuid.uuid4().hex
+    path.mkdir(parents=True)
+    record = {'run_id': path.name, 'state': state, 'finished_at': time.time() - age * 86400, **fields}
+    (path / 'status.json').write_text(json.dumps(record), encoding='utf-8')
+    (path / 'run.log').write_text('evidence', encoding='utf-8')
+    (path / 'custom').mkdir()
+    (path / 'custom' / 'image.png').write_bytes(b'custom evidence')
+    return path
+
+
+def observation(root, age):
+    path = root / 'observations' / f'{uuid.uuid4().hex}.png'
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_bytes(b'image')
+    modified = time.time() - age * 86400
+    os.utime(path, (modified, modified))
+    return path
+
+
+def runner_at(root, **kwargs):
+    return McpTaskRunner(Mock(), Mock(), Mock(), root, **kwargs)
+
+
+def test_startup_expires_completed_runs_and_observations_only(tmp_path):
+    old = [saved_run(tmp_path, state=state) for state in ('succeeded', 'failed', 'cancelled')]
+    recent = saved_run(tmp_path, age=1)
+    unfinished = [saved_run(tmp_path, state=state) for state in ('queued', 'running', 'stopping')]
+    old_image = observation(tmp_path, 8)
+    recent_image = observation(tmp_path, 1)
+    connections = tmp_path / 'connections'
+    connections.mkdir()
+    connection = connections / '1-8765.json'
+    connection.write_text('{}')
+    compatibility = tmp_path / 'connection.json'
+    compatibility.write_text('{}')
+    unknown = tmp_path / 'notes'
+    unknown.mkdir()
+    (unknown / 'notes.txt').write_text('keep')
+    unknown_image = tmp_path / 'observations' / 'manual.png'
+    unknown_image.write_bytes(b'keep')
+    os.utime(unknown_image, (0, 0))
+
+    runner_at(tmp_path)
+
+    assert all(not path.exists() for path in old)
+    assert not old_image.exists()
+    assert all(path.exists() for path in [recent, *unfinished, recent_image, connection,
+                                          compatibility, unknown / 'notes.txt', unknown_image])
+
+
+@pytest.mark.parametrize('contents', ['{', '[]', '{"state": []}', None])
+def test_cleanup_preserves_incomplete_or_malformed_run_records(tmp_path, contents):
+    path = saved_run(tmp_path)
+    status = path / 'status.json'
+    if contents is None:
+        status.unlink()
+    else:
+        status.write_text(contents)
+    runner_at(tmp_path)
+    assert (path / 'run.log').exists()
+
+
+@pytest.mark.parametrize('fields', [{'state': []}, {'finished_at': None}, {'finished_at': '0'},
+                                  {'finished_at': float('nan')}, {'run_id': 'different'}])
+def test_cleanup_preserves_unusable_status_metadata(tmp_path, fields):
+    path = saved_run(tmp_path, **fields)
+    runner_at(tmp_path)
+    assert (path / 'run.log').exists()
+
+
+def test_retention_can_be_configured_or_disabled(tmp_path):
+    path = saved_run(tmp_path, age=3)
+    image = observation(tmp_path, 3)
+    runner_at(tmp_path, retention_days=0)
+    assert path.exists() and image.exists()
+    runner_at(tmp_path, retention_days=2)
+    assert not path.exists() and not image.exists()
+
+
+@pytest.mark.parametrize('retention', [-1, None, '7', True, float('nan'), float('inf')])
+def test_invalid_retention_is_rejected(tmp_path, retention):
+    with pytest.raises(ValueError, match='retention_days'):
+        runner_at(tmp_path, retention_days=retention)
+
+
+def test_cleanup_during_activity_is_throttled_and_expires_memory(development):
+    dev = development
+    task = write_task(dev.root)
+    status = wait_run(dev.runner, dev.runner.run_task(str(task))['run_id'])
+    run_id = status['run_id']
+    record = dev.runner._runs[run_id]['record']
+    record['finished_at'] = time.time() - 8 * 86400
+    dev.runner._save(record)
+    path = Path(status['artifact_directory'])
+
+    # The startup sweep already ran, so requests within the hour leave it alone.
+    dev.runner.screenshot()
+    assert path.exists()
+    dev.runner._next_cleanup = 0
+    dev.runner.screenshot()
+    assert not path.exists()
+    with pytest.raises(ValueError, match='Unknown run_id'):
+        dev.runner.get_run_status(run_id)
+
+    old = saved_run(dev.runner.artifact_directory)
+    dev.runner._next_cleanup = 0
+    assert wait_run(dev.runner, dev.runner.run_task(str(task))['run_id'])['state'] == 'succeeded'
+    assert not old.exists()
+
+
+def test_cleanup_preserves_active_run_even_with_old_terminal_record(development):
+    dev = development
+    task = write_task(dev.root, 'self.executor.next_frame(); self._app.started.set(); self._app.release.wait(3)')
+    run_id = dev.runner.run_task(str(task))['run_id']
+    assert dev.app.started.wait(2)
+    path = Path(dev.runner.get_run_status(run_id)['artifact_directory'])
+    (path / 'status.json').write_text(json.dumps({
+        'run_id': run_id, 'state': 'succeeded', 'finished_at': 0}))
+    dev.runner._next_cleanup = 0
+    dev.runner.screenshot()
+    assert (path / 'run.log').exists()
+    dev.app.release.set()
+    assert wait_run(dev.runner, run_id)['state'] == 'succeeded'
+
+
+def test_cleanup_failure_does_not_block_other_artifacts(tmp_path, monkeypatch):
+    path = saved_run(tmp_path)
+    image = observation(tmp_path, 8)
+    monkeypatch.setattr('ok.core.mcp_runner.shutil.rmtree', Mock(side_effect=PermissionError('locked')))
+    runner_at(tmp_path)
+    assert path.exists()
+    assert not image.exists()
+
+
+def test_cleanup_does_not_follow_directory_junctions(tmp_path):
+    import subprocess
+
+    if os.name != 'nt':
+        pytest.skip('Windows directory junctions')
+    outside = tmp_path / 'outside'
+    saved = saved_run(outside)
+    observation(outside, 8)
+    root = tmp_path / 'mcp'
+    root.mkdir()
+    # A junction needs no elevated symlink privilege on Windows.
+    for link, target in [(root / saved.name, saved), (root / 'observations', outside / 'observations')]:
+        result = subprocess.run(['cmd', '/c', 'mklink', '/J', str(link), str(target)],
+                                capture_output=True, text=True)
+        assert result.returncode == 0, result.stderr
+    runner_at(root)
+    assert (saved / 'run.log').exists()
+    assert len(list((outside / 'observations').glob('*.png'))) == 1

{ok_script-2.0.20 → ok_script-2.0.21}/tests/test_mcp_server.py

@@ -1,6 +1,7 @@
 import asyncio
 import json
 import errno
+import logging
 import os
 import socket
 import threading
@@ -12,9 +13,20 @@ import pytest
 
 from ok.core.mcp_server import LocalMcpServer, bind_mcp_socket, create_mcp_app, discover_mcp_servers
 from ok.util.handler import ExitEvent
+from ok.util.logger import SafeFileHandler
 from test_mcp_runner import development, write_task, register_task
 
 
+@pytest.mark.parametrize('options,expected', [({}, 7), ({'retention_days': 0}, 0), ({'retention_days': 2}, 2)])
+def test_server_passes_artifact_retention_to_runner(development, options, expected):
+    dev = development
+    runtime = SimpleNamespace(task_executor=dev.executor, screenshot=dev.screens,
+                              headless_app=dev.app, should_init_task_manager_headless=lambda: True)
+    server = LocalMcpServer(runtime, {'artifact_directory': str(dev.root / 'http'), **options})
+    assert server.runner.retention_days == expected
+    server.runner.close()
+
+
 @pytest.mark.parametrize('mode', ['auto', 'legacy'])
 def test_http_connection_and_tools_end_to_end(development, mode, monkeypatch):
     pytest.importorskip('mcp')
@@ -134,6 +146,29 @@ def test_http_connection_and_tools_end_to_end(development, mode, monkeypatch):
     assert discover_mcp_servers(dev.root, artifact_directory='http') == []
 
 
+def test_start_keeps_existing_file_log_open(development, tmp_path):
+    pytest.importorskip('mcp')
+    dev = development
+    runtime = SimpleNamespace(task_executor=dev.executor, screenshot=dev.screens,
+                              headless_app=dev.app, exit_event=ExitEvent(),
+                              should_init_task_manager_headless=lambda: True)
+    server = LocalMcpServer(runtime, {'port': 0, 'artifact_directory': str(dev.root / 'http')})
+    # The application configures ok-script.log before it starts the MCP server.
+    log_file = tmp_path / 'ok-script.log'
+    handler = SafeFileHandler(log_file, when='midnight', encoding='utf-8')
+    ok_logger = logging.getLogger('ok')
+    ok_logger.addHandler(handler)
+    try:
+        server.start()
+        ok_logger.warning('logged after MCP start')
+    finally:
+        ok_logger.removeHandler(handler)
+        handler.close()
+        server.stop()
+        server.join()
+    assert 'logged after MCP start' in log_file.read_text(encoding='utf-8')
+
+
 def test_exit_request_is_idempotent_and_does_not_wait_for_runner(development, monkeypatch):
     dev = development
     runtime = SimpleNamespace(task_executor=dev.executor, screenshot=dev.screens,