omi-watcher 0.1.0__tar.gz

omi_watcher-0.1.0/PKG-INFO

@@ -0,0 +1,5 @@
+Metadata-Version: 2.4
+Name: omi-watcher
+Version: 0.1.0
+Summary: A CLI utility for managing background jobs with priority-based scheduling
+Requires-Python: >=3.9

omi_watcher-0.1.0/README.md

@@ -0,0 +1,114 @@
+# omi-watcher
+
+A CLI utility for managing background jobs with priority-based scheduling and eviction.
+
+## Features
+
+- **Queue background jobs** — run any bash command as a managed background job
+- **Priority scheduling** — jobs have priorities: `low`, `medium`, `high`, `critical`
+- **Max 10 concurrent jobs** — higher-priority jobs evict lower-priority ones when full
+- **Eviction with re-queue** — evicted jobs are killed and automatically re-queued
+- **Job monitoring** — view status, logs (stdout/stderr), and exit codes
+- **Persistent state** — SQLite database survives daemon restarts
+
+## Installation
+
+```bash
+cd omi-watcher
+pip install -e .
+```
+
+## Usage
+
+### Start the daemon
+
+```bash
+omi-watcher start
+```
+
+### Submit a job
+
+```bash
+omi-watcher submit "make build" -p high
+omi-watcher submit "python train.py" -p critical
+omi-watcher submit "sleep 60"               # default: medium priority
+```
+
+### Check job status
+
+```bash
+omi-watcher status          # all jobs
+omi-watcher status abc123   # specific job
+```
+
+Example output:
+```
+ID         STATUS       PRIORITY   PID      EXIT   COMMAND
+------------------------------------------------------------------------------
+a1b2c3d4   running      high       12345    -      make build
+e5f6g7h8   queued       medium     -        -      sleep 60
+```
+
+### View job logs
+
+```bash
+omi-watcher logs a1b2c3d4
+```
+
+### Cancel a job
+
+```bash
+omi-watcher cancel a1b2c3d4
+```
+
+### Purge completed/failed jobs
+
+```bash
+omi-watcher purge
+```
+
+### Stop the daemon
+
+```bash
+omi-watcher stop
+```
+
+## Architecture
+
+```
+┌──────────────┐       Unix Socket       ┌──────────────────┐
+│  CLI Client   │ ◄───────────────────► │     Daemon        │
+│  (omi-watcher)│                       │                    │
+└──────────────┘                        │  ┌──────────────┐  │
+                                        │  │  Scheduler   │  │
+                                        │  └──────────────┘  │
+                                        │  ┌──────────────┐  │
+                                        │  │   SQLite DB  │  │
+                                        │  └──────────────┘  │
+                                        │  ┌──────────────┐  │
+                                        │  │  Subprocesses │  │
+                                        │  │  (max 10)     │  │
+                                        │  └──────────────┘  │
+                                        └──────────────────┘
+```
+
+- **Daemon** runs in the background, listening on `~/.omi-watcher/omi-watcher.sock`
+- **Scheduler** picks the highest-priority queued job and launches it
+- When all 10 slots are full and a higher-priority job arrives, the lowest-priority running job is killed and re-queued
+- Job stdout/stderr captured to `~/.omi-watcher/logs/<job_id>.out` and `.err`
+- State persisted in `~/.omi-watcher/omi-watcher.db`
+
+## Priority & Eviction
+
+| Priority | Value |
+|----------|-------|
+| critical | 3     |
+| high     | 2     |
+| medium   | 1     |
+| low      | 0     |
+
+When all 10 slots are occupied and a higher-priority job is submitted:
+1. The lowest-priority running job is selected (ties broken by most recently started)
+2. It receives SIGTERM
+3. It is re-queued with its original priority and an incremented retry count
+4. The new higher-priority job takes its slot

omi_watcher-0.1.0/pyproject.toml

@@ -0,0 +1,15 @@
+[build-system]
+requires = ["setuptools>=64"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "omi-watcher"
+version = "0.1.0"
+description = "A CLI utility for managing background jobs with priority-based scheduling"
+requires-python = ">=3.9"
+
+[project.scripts]
+omi-watcher = "omi_watcher.cli:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]

omi_watcher-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

omi_watcher-0.1.0/src/omi_watcher/__init__.py

@@ -0,0 +1 @@
+"""omi-watcher: Background job queue with priority-based scheduling."""

omi_watcher-0.1.0/src/omi_watcher/cli.py

@@ -0,0 +1,233 @@
+import argparse
+import os
+import signal
+import subprocess
+import sys
+import time
+
+from .models import APP_DIR, PID_FILE, SOCKET_PATH
+from .protocol import client_request
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        prog="omi-watcher",
+        description="Background job queue with priority-based scheduling",
+    )
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    # start
+    sub.add_parser("start", help="Start the daemon")
+
+    # stop
+    sub.add_parser("stop", help="Stop the daemon")
+
+    # submit
+    p_submit = sub.add_parser("submit", help="Submit a job")
+    p_submit.add_argument("cmd", help="Bash command to run")
+    p_submit.add_argument("-p", "--priority", default="medium",
+                          choices=["low", "medium", "high", "critical"],
+                          help="Job priority (default: medium)")
+
+    # status
+    p_status = sub.add_parser("status", help="Show job status")
+    p_status.add_argument("job_id", nargs="?", default=None, help="Job ID (omit for all)")
+
+    # cancel
+    p_cancel = sub.add_parser("cancel", help="Cancel a job")
+    p_cancel.add_argument("job_id", help="Job ID to cancel")
+
+    # logs
+    p_logs = sub.add_parser("logs", help="View job logs")
+    p_logs.add_argument("job_id", help="Job ID")
+
+    # purge
+    sub.add_parser("purge", help="Remove completed/failed jobs")
+
+    args = parser.parse_args()
+
+    handlers = {
+        "start": cmd_start,
+        "stop": cmd_stop,
+        "submit": cmd_submit,
+        "status": cmd_status,
+        "cancel": cmd_cancel,
+        "logs": cmd_logs,
+        "purge": cmd_purge,
+    }
+
+    handlers[args.command](args)
+
+
+def _daemon_running() -> bool:
+    if not os.path.exists(PID_FILE):
+        return False
+    with open(PID_FILE) as f:
+        pid = int(f.read().strip())
+    try:
+        os.kill(pid, 0)
+        return True
+    except ProcessLookupError:
+        return False
+
+
+def _require_daemon():
+    if not _daemon_running():
+        print("Error: Daemon is not running. Start it with: omi-watcher start", file=sys.stderr)
+        sys.exit(1)
+
+
+def cmd_start(args):
+    if _daemon_running():
+        print("Daemon is already running.")
+        return
+
+    os.makedirs(APP_DIR, exist_ok=True)
+
+    # Fork and run daemon in background
+    pid = os.fork()
+    if pid > 0:
+        # Parent: wait briefly for daemon to initialize
+        time.sleep(0.5)
+        if _daemon_running():
+            print(f"Daemon started (PID file: {PID_FILE})")
+        else:
+            print("Warning: Daemon may have failed to start. Check ~/.omi-watcher/daemon.log")
+        return
+
+    # Child: become session leader
+    os.setsid()
+
+    # Second fork to fully detach
+    pid2 = os.fork()
+    if pid2 > 0:
+        os._exit(0)
+
+    # Grandchild: redirect stdio and run daemon
+    sys.stdin.close()
+    devnull = open(os.devnull, "r")
+    os.dup2(devnull.fileno(), 0)
+
+    from .daemon import run_daemon
+    run_daemon()
+    os._exit(0)
+
+
+def cmd_stop(args):
+    _require_daemon()
+    try:
+        resp = client_request(SOCKET_PATH, "stop")
+        if resp.get("ok"):
+            print("Daemon stopping...")
+            # Wait briefly for clean shutdown
+            for _ in range(10):
+                time.sleep(0.3)
+                if not _daemon_running():
+                    print("Daemon stopped.")
+                    return
+            print("Daemon is still shutting down.")
+        else:
+            print(f"Error: {resp.get('error', 'Unknown error')}", file=sys.stderr)
+    except ConnectionRefusedError:
+        print("Error: Could not connect to daemon.", file=sys.stderr)
+
+
+def cmd_submit(args):
+    _require_daemon()
+    resp = client_request(SOCKET_PATH, "submit", {
+        "command": args.cmd,
+        "priority": args.priority,
+    })
+    if resp.get("ok"):
+        job = resp["data"]
+        print(f"Job submitted: {job['id']} (priority: {job['priority']})")
+    else:
+        print(f"Error: {resp.get('error', 'Unknown error')}", file=sys.stderr)
+        sys.exit(1)
+
+
+def cmd_status(args):
+    _require_daemon()
+    payload = {}
+    if args.job_id:
+        payload["job_id"] = args.job_id
+
+    resp = client_request(SOCKET_PATH, "status", payload)
+    if not resp.get("ok"):
+        print(f"Error: {resp.get('error', 'Unknown error')}", file=sys.stderr)
+        sys.exit(1)
+
+    data = resp["data"]
+    if isinstance(data, dict):
+        _print_job(data)
+    elif isinstance(data, list):
+        if not data:
+            print("No jobs found.")
+            return
+        # Table header
+        print(f"{'ID':<10} {'STATUS':<12} {'PRIORITY':<10} {'PID':<8} {'EXIT':<6} {'COMMAND'}")
+        print("-" * 78)
+        for j in data:
+            pid = str(j.get("pid") or "-")
+            exit_code = str(j.get("exit_code") if j.get("exit_code") is not None else "-")
+            cmd_display = j["command"][:40]
+            print(f"{j['id']:<10} {j['status']:<12} {j['priority']:<10} {pid:<8} {exit_code:<6} {cmd_display}")
+
+
+def _print_job(j: dict):
+    print(f"Job ID:      {j['id']}")
+    print(f"Command:     {j['command']}")
+    print(f"Status:      {j['status']}")
+    print(f"Priority:    {j['priority']}")
+    print(f"PID:         {j.get('pid') or '-'}")
+    print(f"Exit Code:   {j['exit_code'] if j.get('exit_code') is not None else '-'}")
+    print(f"Created:     {j.get('created_at', '-')}")
+    print(f"Started:     {j.get('started_at') or '-'}")
+    print(f"Finished:    {j.get('finished_at') or '-'}")
+    print(f"Retries:     {j.get('retry_count', 0)}")
+
+
+def cmd_cancel(args):
+    _require_daemon()
+    resp = client_request(SOCKET_PATH, "cancel", {"job_id": args.job_id})
+    if resp.get("ok"):
+        print(f"Job {args.job_id} cancelled.")
+    else:
+        print(f"Error: {resp.get('error', 'Unknown error')}", file=sys.stderr)
+        sys.exit(1)
+
+
+def cmd_logs(args):
+    _require_daemon()
+    resp = client_request(SOCKET_PATH, "logs", {"job_id": args.job_id})
+    if not resp.get("ok"):
+        print(f"Error: {resp.get('error', 'Unknown error')}", file=sys.stderr)
+        sys.exit(1)
+
+    data = resp["data"]
+    stdout = data.get("stdout", "")
+    stderr = data.get("stderr", "")
+
+    if stdout:
+        print("=== STDOUT ===")
+        print(stdout)
+    if stderr:
+        print("=== STDERR ===")
+        print(stderr)
+    if not stdout and not stderr:
+        print("No logs available for this job.")
+
+
+def cmd_purge(args):
+    _require_daemon()
+    resp = client_request(SOCKET_PATH, "purge")
+    if resp.get("ok"):
+        count = resp["data"]["purged"]
+        print(f"Purged {count} completed/failed job(s).")
+    else:
+        print(f"Error: {resp.get('error', 'Unknown error')}", file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

omi_watcher-0.1.0/src/omi_watcher/daemon.py

@@ -0,0 +1,319 @@
+import logging
+import os
+import select
+import signal
+import socket
+import subprocess
+import sys
+import threading
+import time
+from typing import Dict, Optional
+
+from .db import (
+    get_connection,
+    get_job,
+    get_running_jobs,
+    init_db,
+    insert_job,
+    list_jobs,
+    purge_completed,
+    update_job_status,
+)
+from .models import (
+    APP_DIR,
+    LOG_DIR,
+    PID_FILE,
+    SOCKET_PATH,
+    JobStatus,
+    Priority,
+)
+from .protocol import make_response, recv_message, send_message
+from .scheduler import evict_job, pick_next_job, should_evict
+
+logger = logging.getLogger("omi-watcher-daemon")
+
+
+class Daemon:
+    def __init__(self):
+        self._running = False
+        self._processes: Dict[str, subprocess.Popen] = {}  # job_id -> Popen
+        self._conn = None
+        self._server_sock = None
+
+    def start(self):
+        os.makedirs(APP_DIR, exist_ok=True)
+        os.makedirs(LOG_DIR, exist_ok=True)
+
+        self._setup_logging()
+        self._write_pid()
+        self._conn = get_connection()
+        init_db(self._conn)
+
+        # Mark any previously "running" jobs as failed (stale from prior crash)
+        for job in get_running_jobs(self._conn):
+            update_job_status(self._conn, job.id, JobStatus.FAILED, exit_code=-1)
+
+        self._setup_socket()
+        self._running = True
+
+        signal.signal(signal.SIGTERM, self._handle_signal)
+        signal.signal(signal.SIGINT, self._handle_signal)
+
+        logger.info("Daemon started (PID %d)", os.getpid())
+        self._main_loop()
+
+    def _setup_logging(self):
+        log_file = os.path.join(APP_DIR, "daemon.log")
+        logging.basicConfig(
+            filename=log_file,
+            level=logging.INFO,
+            format="%(asctime)s %(levelname)s %(message)s",
+        )
+
+    def _write_pid(self):
+        with open(PID_FILE, "w") as f:
+            f.write(str(os.getpid()))
+
+    def _setup_socket(self):
+        if os.path.exists(SOCKET_PATH):
+            os.unlink(SOCKET_PATH)
+        self._server_sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+        self._server_sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+        self._server_sock.bind(SOCKET_PATH)
+        self._server_sock.listen(5)
+        self._server_sock.setblocking(False)
+
+    def _handle_signal(self, signum, frame):
+        logger.info("Received signal %d, shutting down", signum)
+        self._running = False
+
+    def _main_loop(self):
+        while self._running:
+            # Accept client connections (non-blocking)
+            try:
+                readable, _, _ = select.select([self._server_sock], [], [], 0.5)
+                for sock in readable:
+                    client, _ = sock.accept()
+                    try:
+                        self._handle_client(client)
+                    except Exception as e:
+                        logger.error("Error handling client: %s", e)
+                    finally:
+                        client.close()
+            except OSError:
+                break
+
+            # Reap completed processes
+            self._reap_processes()
+
+            # Schedule queued jobs
+            self._schedule_jobs()
+
+        self._shutdown()
+
+    def _handle_client(self, client: socket.socket):
+        msg = recv_message(client)
+        if not msg:
+            return
+
+        action = msg.get("action", "")
+        payload = msg.get("payload", {})
+
+        handler = {
+            "submit": self._cmd_submit,
+            "status": self._cmd_status,
+            "cancel": self._cmd_cancel,
+            "logs": self._cmd_logs,
+            "purge": self._cmd_purge,
+            "stop": self._cmd_stop,
+        }.get(action)
+
+        if handler:
+            response = handler(payload)
+        else:
+            response = make_response(False, error=f"Unknown action: {action}")
+
+        send_message(client, response)
+
+    def _cmd_submit(self, payload: dict) -> dict:
+        command = payload.get("command")
+        priority_str = payload.get("priority", "medium")
+        if not command:
+            return make_response(False, error="No command provided")
+
+        try:
+            priority = Priority.from_str(priority_str)
+        except (KeyError, ValueError):
+            return make_response(False, error=f"Invalid priority: {priority_str}")
+
+        job = insert_job(self._conn, command, priority)
+        logger.info("Job %s submitted: %s (priority=%s)", job.id, command, priority.name)
+
+        # Immediately try to schedule
+        self._schedule_jobs()
+
+        return make_response(True, data=job.to_dict())
+
+    def _cmd_status(self, payload: dict) -> dict:
+        job_id = payload.get("job_id")
+        if job_id:
+            job = get_job(self._conn, job_id)
+            if not job:
+                return make_response(False, error=f"Job {job_id} not found")
+            return make_response(True, data=job.to_dict())
+        else:
+            jobs = list_jobs(self._conn)
+            return make_response(True, data=[j.to_dict() for j in jobs])
+
+    def _cmd_cancel(self, payload: dict) -> dict:
+        job_id = payload.get("job_id")
+        if not job_id:
+            return make_response(False, error="No job_id provided")
+
+        job = get_job(self._conn, job_id)
+        if not job:
+            return make_response(False, error=f"Job {job_id} not found")
+
+        if job.status == JobStatus.RUNNING and job.pid:
+            proc = self._processes.get(job_id)
+            if proc:
+                try:
+                    proc.terminate()
+                except ProcessLookupError:
+                    pass
+
+        if job.status in (JobStatus.QUEUED, JobStatus.RUNNING):
+            update_job_status(self._conn, job_id, JobStatus.CANCELLED)
+            logger.info("Job %s cancelled", job_id)
+            return make_response(True, data={"job_id": job_id, "status": "cancelled"})
+
+        return make_response(False, error=f"Job {job_id} is {job.status.value}, cannot cancel")
+
+    def _cmd_logs(self, payload: dict) -> dict:
+        job_id = payload.get("job_id")
+        if not job_id:
+            return make_response(False, error="No job_id provided")
+
+        stdout_path = os.path.join(LOG_DIR, f"{job_id}.out")
+        stderr_path = os.path.join(LOG_DIR, f"{job_id}.err")
+
+        result = {}
+        if os.path.exists(stdout_path):
+            with open(stdout_path, "r") as f:
+                result["stdout"] = f.read()
+        else:
+            result["stdout"] = ""
+
+        if os.path.exists(stderr_path):
+            with open(stderr_path, "r") as f:
+                result["stderr"] = f.read()
+        else:
+            result["stderr"] = ""
+
+        return make_response(True, data=result)
+
+    def _cmd_purge(self, payload: dict) -> dict:
+        count = purge_completed(self._conn)
+        return make_response(True, data={"purged": count})
+
+    def _cmd_stop(self, payload: dict) -> dict:
+        self._running = False
+        return make_response(True, data={"message": "Daemon stopping"})
+
+    def _reap_processes(self):
+        finished = []
+        for job_id, proc in self._processes.items():
+            ret = proc.poll()
+            if ret is not None:
+                finished.append((job_id, ret))
+
+        for job_id, ret in finished:
+            del self._processes[job_id]
+            status = JobStatus.COMPLETED if ret == 0 else JobStatus.FAILED
+            update_job_status(self._conn, job_id, status, exit_code=ret)
+            logger.info("Job %s finished with exit code %d (%s)", job_id, ret, status.value)
+
+    def _schedule_jobs(self):
+        running_jobs = get_running_jobs(self._conn)
+        running_count = len(running_jobs)
+
+        while True:
+            next_job = pick_next_job(self._conn)
+            if not next_job:
+                break
+
+            if running_count < 10:
+                self._launch_job(next_job)
+                running_count += 1
+            else:
+                victim = should_evict(next_job, running_jobs)
+                if victim:
+                    logger.info("Evicting job %s (pri=%s) for job %s (pri=%s)",
+                                victim.id, victim.priority.name, next_job.id, next_job.priority.name)
+                    proc = self._processes.pop(victim.id, None)
+                    if proc:
+                        try:
+                            proc.terminate()
+                        except ProcessLookupError:
+                            pass
+                    evict_job(victim, self._conn)
+                    self._launch_job(next_job)
+                    # Refresh running jobs list after eviction
+                    running_jobs = get_running_jobs(self._conn)
+                else:
+                    break
+
+    def _launch_job(self, job):
+        stdout_path = os.path.join(LOG_DIR, f"{job.id}.out")
+        stderr_path = os.path.join(LOG_DIR, f"{job.id}.err")
+
+        stdout_f = open(stdout_path, "w")
+        stderr_f = open(stderr_path, "w")
+
+        try:
+            proc = subprocess.Popen(
+                job.command,
+                shell=True,
+                stdout=stdout_f,
+                stderr=stderr_f,
+                start_new_session=True,
+            )
+        except Exception as e:
+            stdout_f.close()
+            stderr_f.close()
+            update_job_status(self._conn, job.id, JobStatus.FAILED)
+            logger.error("Failed to launch job %s: %s", job.id, e)
+            return
+
+        self._processes[job.id] = proc
+        update_job_status(self._conn, job.id, JobStatus.RUNNING, pid=proc.pid)
+        logger.info("Launched job %s (PID %d): %s", job.id, proc.pid, job.command)
+
+    def _shutdown(self):
+        logger.info("Shutting down daemon")
+        # Terminate all running jobs
+        for job_id, proc in self._processes.items():
+            try:
+                proc.terminate()
+            except ProcessLookupError:
+                pass
+            update_job_status(self._conn, job_id, JobStatus.FAILED, exit_code=-15)
+
+        self._processes.clear()
+
+        if self._server_sock:
+            self._server_sock.close()
+        if os.path.exists(SOCKET_PATH):
+            os.unlink(SOCKET_PATH)
+        if os.path.exists(PID_FILE):
+            os.unlink(PID_FILE)
+        if self._conn:
+            self._conn.close()
+
+        logger.info("Daemon stopped")
+
+
+def run_daemon():
+    """Entry point to run the daemon (called after daemonizing)."""
+    daemon = Daemon()
+    daemon.start()

omi_watcher-0.1.0/src/omi_watcher/db.py

@@ -0,0 +1,128 @@
+import os
+import sqlite3
+from datetime import datetime, timezone
+from typing import List, Optional
+
+from .models import APP_DIR, DB_PATH, Job, JobStatus, Priority
+
+
+def _ensure_dir():
+    os.makedirs(APP_DIR, exist_ok=True)
+
+
+def get_connection() -> sqlite3.Connection:
+    _ensure_dir()
+    conn = sqlite3.connect(DB_PATH)
+    conn.row_factory = sqlite3.Row
+    conn.execute("PRAGMA journal_mode=WAL")
+    return conn
+
+
+def init_db(conn: sqlite3.Connection):
+    conn.execute("""
+        CREATE TABLE IF NOT EXISTS jobs (
+            id TEXT PRIMARY KEY,
+            command TEXT NOT NULL,
+            priority INTEGER NOT NULL,
+            status TEXT NOT NULL DEFAULT 'queued',
+            pid INTEGER,
+            created_at TEXT NOT NULL,
+            started_at TEXT,
+            finished_at TEXT,
+            exit_code INTEGER,
+            retry_count INTEGER NOT NULL DEFAULT 0
+        )
+    """)
+    conn.commit()
+
+
+def _now() -> str:
+    return datetime.now(timezone.utc).isoformat()
+
+
+def _row_to_job(row: sqlite3.Row) -> Job:
+    return Job(
+        id=row["id"],
+        command=row["command"],
+        priority=Priority(row["priority"]),
+        status=JobStatus(row["status"]),
+        pid=row["pid"],
+        created_at=row["created_at"],
+        started_at=row["started_at"],
+        finished_at=row["finished_at"],
+        exit_code=row["exit_code"],
+        retry_count=row["retry_count"],
+    )
+
+
+def insert_job(conn: sqlite3.Connection, command: str, priority: Priority) -> Job:
+    import uuid
+    job_id = uuid.uuid4().hex[:8]
+    now = _now()
+    conn.execute(
+        "INSERT INTO jobs (id, command, priority, status, created_at, retry_count) VALUES (?, ?, ?, ?, ?, ?)",
+        (job_id, command, priority.value, JobStatus.QUEUED.value, now, 0),
+    )
+    conn.commit()
+    return Job(id=job_id, command=command, priority=priority, status=JobStatus.QUEUED, created_at=now)
+
+
+def requeue_job(conn: sqlite3.Connection, job: Job):
+    conn.execute(
+        "UPDATE jobs SET status = ?, pid = NULL, started_at = NULL, finished_at = NULL, exit_code = NULL, retry_count = ? WHERE id = ?",
+        (JobStatus.QUEUED.value, job.retry_count + 1, job.id),
+    )
+    conn.commit()
+
+
+def update_job_status(conn: sqlite3.Connection, job_id: str, status: JobStatus,
+                      pid: Optional[int] = None, exit_code: Optional[int] = None):
+    now = _now()
+    if status == JobStatus.RUNNING:
+        conn.execute("UPDATE jobs SET status = ?, pid = ?, started_at = ? WHERE id = ?",
+                      (status.value, pid, now, job_id))
+    elif status in (JobStatus.COMPLETED, JobStatus.FAILED, JobStatus.CANCELLED, JobStatus.EVICTED):
+        conn.execute("UPDATE jobs SET status = ?, finished_at = ?, exit_code = ? WHERE id = ?",
+                      (status.value, now, exit_code, job_id))
+    else:
+        conn.execute("UPDATE jobs SET status = ? WHERE id = ?", (status.value, job_id))
+    conn.commit()
+
+
+def get_job(conn: sqlite3.Connection, job_id: str) -> Optional[Job]:
+    row = conn.execute("SELECT * FROM jobs WHERE id = ?", (job_id,)).fetchone()
+    return _row_to_job(row) if row else None
+
+
+def list_jobs(conn: sqlite3.Connection, status: Optional[JobStatus] = None) -> List[Job]:
+    if status:
+        rows = conn.execute("SELECT * FROM jobs WHERE status = ? ORDER BY priority DESC, created_at ASC",
+                            (status.value,)).fetchall()
+    else:
+        rows = conn.execute("SELECT * FROM jobs ORDER BY created_at DESC").fetchall()
+    return [_row_to_job(r) for r in rows]
+
+
+def get_queued_jobs(conn: sqlite3.Connection) -> List[Job]:
+    rows = conn.execute(
+        "SELECT * FROM jobs WHERE status = ? ORDER BY priority DESC, created_at ASC",
+        (JobStatus.QUEUED.value,),
+    ).fetchall()
+    return [_row_to_job(r) for r in rows]
+
+
+def get_running_jobs(conn: sqlite3.Connection) -> List[Job]:
+    rows = conn.execute(
+        "SELECT * FROM jobs WHERE status = ? ORDER BY priority ASC, started_at DESC",
+        (JobStatus.RUNNING.value,),
+    ).fetchall()
+    return [_row_to_job(r) for r in rows]
+
+
+def purge_completed(conn: sqlite3.Connection) -> int:
+    cursor = conn.execute(
+        "DELETE FROM jobs WHERE status IN (?, ?)",
+        (JobStatus.COMPLETED.value, JobStatus.FAILED.value),
+    )
+    conn.commit()
+    return cursor.rowcount

omi_watcher-0.1.0/src/omi_watcher/models.py

@@ -0,0 +1,75 @@
+import enum
+import os
+from dataclasses import dataclass, field
+from typing import Optional
+
+# Constants
+APP_DIR = os.path.join(os.path.expanduser("~"), ".omi-watcher")
+DB_PATH = os.path.join(APP_DIR, "omi-watcher.db")
+SOCKET_PATH = os.path.join(APP_DIR, "omi-watcher.sock")
+PID_FILE = os.path.join(APP_DIR, "omi-watcher.pid")
+LOG_DIR = os.path.join(APP_DIR, "logs")
+MAX_CONCURRENT_JOBS = 10
+
+
+class Priority(enum.IntEnum):
+    LOW = 0
+    MEDIUM = 1
+    HIGH = 2
+    CRITICAL = 3
+
+    @classmethod
+    def from_str(cls, s: str) -> "Priority":
+        return cls[s.upper()]
+
+
+class JobStatus(str, enum.Enum):
+    QUEUED = "queued"
+    RUNNING = "running"
+    COMPLETED = "completed"
+    FAILED = "failed"
+    CANCELLED = "cancelled"
+    EVICTED = "evicted"
+
+
+@dataclass
+class Job:
+    id: str
+    command: str
+    priority: Priority
+    status: JobStatus = JobStatus.QUEUED
+    pid: Optional[int] = None
+    created_at: Optional[str] = None
+    started_at: Optional[str] = None
+    finished_at: Optional[str] = None
+    exit_code: Optional[int] = None
+    retry_count: int = 0
+
+    def to_dict(self) -> dict:
+        return {
+            "id": self.id,
+            "command": self.command,
+            "priority": self.priority.name.lower(),
+            "status": self.status.value,
+            "pid": self.pid,
+            "created_at": self.created_at,
+            "started_at": self.started_at,
+            "finished_at": self.finished_at,
+            "exit_code": self.exit_code,
+            "retry_count": self.retry_count,
+        }
+
+    @classmethod
+    def from_dict(cls, d: dict) -> "Job":
+        return cls(
+            id=d["id"],
+            command=d["command"],
+            priority=Priority[d["priority"].upper()] if isinstance(d["priority"], str) else Priority(d["priority"]),
+            status=JobStatus(d["status"]),
+            pid=d.get("pid"),
+            created_at=d.get("created_at"),
+            started_at=d.get("started_at"),
+            finished_at=d.get("finished_at"),
+            exit_code=d.get("exit_code"),
+            retry_count=d.get("retry_count", 0),
+        )

omi_watcher-0.1.0/src/omi_watcher/protocol.py

@@ -0,0 +1,54 @@
+import json
+import socket
+import struct
+from typing import Any, Dict, Optional
+
+HEADER_FORMAT = "!I"  # 4-byte unsigned int, network byte order
+HEADER_SIZE = struct.calcsize(HEADER_FORMAT)
+
+
+def make_request(action: str, payload: Optional[Dict] = None) -> Dict:
+    return {"action": action, "payload": payload or {}}
+
+
+def make_response(ok: bool, data: Any = None, error: Optional[str] = None) -> Dict:
+    return {"ok": ok, "data": data, "error": error}
+
+
+def send_message(sock: socket.socket, msg: Dict):
+    data = json.dumps(msg).encode("utf-8")
+    header = struct.pack(HEADER_FORMAT, len(data))
+    sock.sendall(header + data)
+
+
+def recv_message(sock: socket.socket) -> Optional[Dict]:
+    header = _recv_exact(sock, HEADER_SIZE)
+    if not header:
+        return None
+    (length,) = struct.unpack(HEADER_FORMAT, header)
+    data = _recv_exact(sock, length)
+    if not data:
+        return None
+    return json.loads(data.decode("utf-8"))
+
+
+def _recv_exact(sock: socket.socket, n: int) -> Optional[bytes]:
+    buf = bytearray()
+    while len(buf) < n:
+        chunk = sock.recv(n - len(buf))
+        if not chunk:
+            return None
+        buf.extend(chunk)
+    return bytes(buf)
+
+
+def client_request(socket_path: str, action: str, payload: Optional[Dict] = None) -> Dict:
+    """Send a request to the daemon and return the response."""
+    sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+    try:
+        sock.connect(socket_path)
+        send_message(sock, make_request(action, payload))
+        response = recv_message(sock)
+        return response or make_response(False, error="No response from daemon")
+    finally:
+        sock.close()

omi_watcher-0.1.0/src/omi_watcher/scheduler.py

@@ -0,0 +1,44 @@
+import os
+import signal
+import sqlite3
+from typing import Optional
+
+from .db import get_queued_jobs, get_running_jobs, requeue_job, update_job_status
+from .models import Job, JobStatus, MAX_CONCURRENT_JOBS
+
+
+def pick_next_job(conn: sqlite3.Connection) -> Optional[Job]:
+    """Return the highest-priority queued job, or None."""
+    jobs = get_queued_jobs(conn)
+    return jobs[0] if jobs else None
+
+
+def should_evict(new_job: Job, running_jobs: list[Job]) -> Optional[Job]:
+    """If all slots are full and new_job has higher priority than the
+    lowest-priority running job, return that job for eviction."""
+    if len(running_jobs) < MAX_CONCURRENT_JOBS:
+        return None
+    # running_jobs sorted by priority ASC, started_at DESC (from DB query)
+    # so first element is lowest priority, most recently started
+    lowest = running_jobs[0]
+    if new_job.priority > lowest.priority:
+        return lowest
+    return None
+
+
+def evict_job(job: Job, conn: sqlite3.Connection) -> bool:
+    """Kill the running job, mark as evicted, then re-queue it."""
+    if job.pid:
+        try:
+            os.kill(job.pid, signal.SIGTERM)
+        except ProcessLookupError:
+            pass
+    update_job_status(conn, job.id, JobStatus.EVICTED)
+    requeue_job(conn, job)
+    return True
+
+
+def get_slot_count(conn: sqlite3.Connection) -> int:
+    """Return number of available job slots."""
+    running = get_running_jobs(conn)
+    return MAX_CONCURRENT_JOBS - len(running)

omi_watcher-0.1.0/src/omi_watcher.egg-info/PKG-INFO

@@ -0,0 +1,5 @@
+Metadata-Version: 2.4
+Name: omi-watcher
+Version: 0.1.0
+Summary: A CLI utility for managing background jobs with priority-based scheduling
+Requires-Python: >=3.9

omi_watcher-0.1.0/src/omi_watcher.egg-info/SOURCES.txt

@@ -0,0 +1,17 @@
+README.md
+pyproject.toml
+src/omi_watcher/__init__.py
+src/omi_watcher/cli.py
+src/omi_watcher/daemon.py
+src/omi_watcher/db.py
+src/omi_watcher/models.py
+src/omi_watcher/protocol.py
+src/omi_watcher/scheduler.py
+src/omi_watcher.egg-info/PKG-INFO
+src/omi_watcher.egg-info/SOURCES.txt
+src/omi_watcher.egg-info/dependency_links.txt
+src/omi_watcher.egg-info/entry_points.txt
+src/omi_watcher.egg-info/top_level.txt
+tests/test_db.py
+tests/test_integration.py
+tests/test_scheduler.py

omi_watcher-0.1.0/src/omi_watcher.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

omi_watcher-0.1.0/src/omi_watcher.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+omi-watcher = omi_watcher.cli:main

omi_watcher-0.1.0/src/omi_watcher.egg-info/top_level.txt

@@ -0,0 +1 @@
+omi_watcher

omi_watcher-0.1.0/tests/test_db.py

@@ -0,0 +1,86 @@
+import os
+import sqlite3
+import tempfile
+import unittest
+
+from omi_watcher.db import (
+    get_connection,
+    get_job,
+    get_queued_jobs,
+    get_running_jobs,
+    init_db,
+    insert_job,
+    list_jobs,
+    purge_completed,
+    requeue_job,
+    update_job_status,
+)
+from omi_watcher.models import JobStatus, Priority
+
+
+class TestDB(unittest.TestCase):
+    def setUp(self):
+        self.conn = sqlite3.connect(":memory:")
+        self.conn.row_factory = sqlite3.Row
+        init_db(self.conn)
+
+    def tearDown(self):
+        self.conn.close()
+
+    def test_insert_and_get(self):
+        job = insert_job(self.conn, "echo hello", Priority.HIGH)
+        self.assertIsNotNone(job.id)
+        self.assertEqual(job.command, "echo hello")
+        self.assertEqual(job.priority, Priority.HIGH)
+        self.assertEqual(job.status, JobStatus.QUEUED)
+
+        fetched = get_job(self.conn, job.id)
+        self.assertIsNotNone(fetched)
+        self.assertEqual(fetched.command, "echo hello")
+
+    def test_list_jobs(self):
+        insert_job(self.conn, "cmd1", Priority.LOW)
+        insert_job(self.conn, "cmd2", Priority.HIGH)
+        jobs = list_jobs(self.conn)
+        self.assertEqual(len(jobs), 2)
+
+    def test_update_status(self):
+        job = insert_job(self.conn, "echo test", Priority.MEDIUM)
+        update_job_status(self.conn, job.id, JobStatus.RUNNING, pid=1234)
+        fetched = get_job(self.conn, job.id)
+        self.assertEqual(fetched.status, JobStatus.RUNNING)
+        self.assertEqual(fetched.pid, 1234)
+
+    def test_queued_jobs_ordered_by_priority(self):
+        insert_job(self.conn, "low", Priority.LOW)
+        insert_job(self.conn, "critical", Priority.CRITICAL)
+        insert_job(self.conn, "medium", Priority.MEDIUM)
+        queued = get_queued_jobs(self.conn)
+        self.assertEqual(queued[0].command, "critical")
+        self.assertEqual(queued[1].command, "medium")
+        self.assertEqual(queued[2].command, "low")
+
+    def test_purge_completed(self):
+        j1 = insert_job(self.conn, "done", Priority.LOW)
+        j2 = insert_job(self.conn, "fail", Priority.LOW)
+        j3 = insert_job(self.conn, "still running", Priority.LOW)
+        update_job_status(self.conn, j1.id, JobStatus.COMPLETED)
+        update_job_status(self.conn, j2.id, JobStatus.FAILED)
+        update_job_status(self.conn, j3.id, JobStatus.RUNNING, pid=999)
+        count = purge_completed(self.conn)
+        self.assertEqual(count, 2)
+        self.assertIsNone(get_job(self.conn, j1.id))
+        self.assertIsNotNone(get_job(self.conn, j3.id))
+
+    def test_requeue_job(self):
+        job = insert_job(self.conn, "requeue me", Priority.HIGH)
+        update_job_status(self.conn, job.id, JobStatus.RUNNING, pid=100)
+        requeue_job(self.conn, get_job(self.conn, job.id))
+        fetched = get_job(self.conn, job.id)
+        self.assertEqual(fetched.status, JobStatus.QUEUED)
+        self.assertEqual(fetched.retry_count, 1)
+        self.assertIsNone(fetched.pid)
+
+
+if __name__ == "__main__":
+    unittest.main()

omi_watcher-0.1.0/tests/test_integration.py

@@ -0,0 +1,105 @@
+import os
+import subprocess
+import sys
+import time
+import unittest
+
+from omi_watcher.models import APP_DIR, PID_FILE, SOCKET_PATH
+from omi_watcher.protocol import client_request
+
+
+class TestIntegration(unittest.TestCase):
+    """Integration tests that start a real daemon and interact with it."""
+
+    @classmethod
+    def setUpClass(cls):
+        # Start daemon via subprocess (fork-based, parent returns quickly)
+        proc = subprocess.Popen(
+            [sys.executable, "-m", "omi_watcher.cli", "start"],
+            stdout=subprocess.PIPE, stderr=subprocess.PIPE,
+        )
+        proc.wait(timeout=10)
+        # Wait for daemon to be ready
+        for _ in range(20):
+            if os.path.exists(SOCKET_PATH):
+                break
+            time.sleep(0.25)
+
+    @classmethod
+    def tearDownClass(cls):
+        # Stop daemon
+        try:
+            client_request(SOCKET_PATH, "stop")
+            time.sleep(1)
+        except Exception:
+            pass
+        # Clean up PID file if still present
+        if os.path.exists(PID_FILE):
+            with open(PID_FILE) as f:
+                pid = int(f.read().strip())
+            try:
+                os.kill(pid, 9)
+            except ProcessLookupError:
+                pass
+
+    def test_01_submit_job(self):
+        resp = client_request(SOCKET_PATH, "submit", {
+            "command": "echo hello world",
+            "priority": "medium",
+        })
+        self.assertTrue(resp["ok"])
+        self.assertIn("id", resp["data"])
+        self.__class__._job_id = resp["data"]["id"]
+
+    def test_02_status_all(self):
+        time.sleep(1)  # Let job complete
+        resp = client_request(SOCKET_PATH, "status")
+        self.assertTrue(resp["ok"])
+        self.assertIsInstance(resp["data"], list)
+        self.assertGreater(len(resp["data"]), 0)
+
+    def test_03_status_single(self):
+        job_id = getattr(self.__class__, "_job_id", None)
+        if not job_id:
+            self.skipTest("No job ID from previous test")
+        time.sleep(1)
+        resp = client_request(SOCKET_PATH, "status", {"job_id": job_id})
+        self.assertTrue(resp["ok"])
+        self.assertEqual(resp["data"]["id"], job_id)
+
+    def test_04_logs(self):
+        job_id = getattr(self.__class__, "_job_id", None)
+        if not job_id:
+            self.skipTest("No job ID from previous test")
+        time.sleep(1)
+        resp = client_request(SOCKET_PATH, "logs", {"job_id": job_id})
+        self.assertTrue(resp["ok"])
+
+    def test_05_submit_with_priority(self):
+        resp = client_request(SOCKET_PATH, "submit", {
+            "command": "sleep 0.1",
+            "priority": "critical",
+        })
+        self.assertTrue(resp["ok"])
+        self.assertEqual(resp["data"]["priority"], "critical")
+
+    def test_06_cancel_queued_job(self):
+        resp = client_request(SOCKET_PATH, "submit", {
+            "command": "sleep 3600",
+            "priority": "low",
+        })
+        self.assertTrue(resp["ok"])
+        job_id = resp["data"]["id"]
+        time.sleep(0.5)
+        resp = client_request(SOCKET_PATH, "cancel", {"job_id": job_id})
+        self.assertTrue(resp["ok"])
+
+    def test_07_purge(self):
+        time.sleep(2)  # Let jobs finish
+        resp = client_request(SOCKET_PATH, "purge")
+        self.assertTrue(resp["ok"])
+        self.assertIn("purged", resp["data"])
+
+
+if __name__ == "__main__":
+    unittest.main()

omi_watcher-0.1.0/tests/test_scheduler.py

@@ -0,0 +1,82 @@
+import sqlite3
+import unittest
+
+from omi_watcher.db import (
+    get_queued_jobs,
+    get_running_jobs,
+    init_db,
+    insert_job,
+    update_job_status,
+)
+from omi_watcher.models import Job, JobStatus, Priority
+from omi_watcher.scheduler import pick_next_job, should_evict
+
+
+class TestScheduler(unittest.TestCase):
+    def setUp(self):
+        self.conn = sqlite3.connect(":memory:")
+        self.conn.row_factory = sqlite3.Row
+        init_db(self.conn)
+
+    def tearDown(self):
+        self.conn.close()
+
+    def test_pick_next_job_highest_priority(self):
+        insert_job(self.conn, "low cmd", Priority.LOW)
+        insert_job(self.conn, "high cmd", Priority.HIGH)
+        insert_job(self.conn, "medium cmd", Priority.MEDIUM)
+        job = pick_next_job(self.conn)
+        self.assertEqual(job.command, "high cmd")
+
+    def test_pick_next_job_none_when_empty(self):
+        job = pick_next_job(self.conn)
+        self.assertIsNone(job)
+
+    def test_should_evict_when_slots_full(self):
+        # Create 10 running jobs at LOW priority
+        running = []
+        for i in range(10):
+            j = insert_job(self.conn, f"running {i}", Priority.LOW)
+            update_job_status(self.conn, j.id, JobStatus.RUNNING, pid=1000 + i)
+
+        running_jobs = get_running_jobs(self.conn)
+        new_job = Job(id="new", command="important", priority=Priority.CRITICAL)
+        victim = should_evict(new_job, running_jobs)
+        self.assertIsNotNone(victim)
+        self.assertEqual(victim.priority, Priority.LOW)
+
+    def test_no_evict_when_slots_available(self):
+        # Only 5 running jobs
+        for i in range(5):
+            j = insert_job(self.conn, f"running {i}", Priority.LOW)
+            update_job_status(self.conn, j.id, JobStatus.RUNNING, pid=1000 + i)
+
+        running_jobs = get_running_jobs(self.conn)
+        new_job = Job(id="new", command="important", priority=Priority.CRITICAL)
+        victim = should_evict(new_job, running_jobs)
+        self.assertIsNone(victim)
+
+    def test_no_evict_when_same_priority(self):
+        running = []
+        for i in range(10):
+            j = insert_job(self.conn, f"running {i}", Priority.MEDIUM)
+            update_job_status(self.conn, j.id, JobStatus.RUNNING, pid=1000 + i)
+
+        running_jobs = get_running_jobs(self.conn)
+        new_job = Job(id="new", command="same pri", priority=Priority.MEDIUM)
+        victim = should_evict(new_job, running_jobs)
+        self.assertIsNone(victim)
+
+    def test_no_evict_when_lower_priority(self):
+        for i in range(10):
+            j = insert_job(self.conn, f"running {i}", Priority.HIGH)
+            update_job_status(self.conn, j.id, JobStatus.RUNNING, pid=1000 + i)
+
+        running_jobs = get_running_jobs(self.conn)
+        new_job = Job(id="new", command="low pri", priority=Priority.LOW)
+        victim = should_evict(new_job, running_jobs)
+        self.assertIsNone(victim)
+
+
+if __name__ == "__main__":
+    unittest.main()