Now using SQLite

Author: jet-logic

README.md

@@ -176,23 +176,23 @@ runce restart my-unique-task
 runce run --id api-server -- python api.py
 ```
 
-### 2. Checking Running Processes
+### 2. Checking Live Processes
 
 ```bash
 $ runce list
 PID     NAME        STATUS      ELAPSED    COMMAND
-1234    api-server  ✅ Running  01:23:45   python api.py
-5678    worker      ❌ Stopped  00:45:30   python worker.py
+1234    api-server  ✅ Live  01:23:45   python api.py
+5678    worker      ❌ Gone  00:45:30   python worker.py
 ```
 
 ### 3. Preventing Duplicates
 
 ```bash
 $ runce run --id daily-job -- python daily.py
-🚀 Started: PID:5678(✅ Running) daily-job
+🚀 Started: PID:5678(✅ Live) daily-job
 
 $ runce run --id daily-job -- python daily.py
-🚨 Already running: PID:5678(✅ Running) daily-job
+🚨 Already running: PID:5678(✅ Live) daily-job
 ```
 
 ## Formats
@@ -201,7 +201,7 @@ The `-f` / `--format` option in the `ls` and `status` commands allows you to cus
 
 - `{pid}`: Process ID
 - `{name}`: Run ID / Name
-- `{pid_status}`: Process status ("✅ Running" or "👻 Absent")
+- `{pid_status}`: Process status ("✅ Live" or "👻 Gone")
 - `{elapsed}`: Elapsed time
 - `{command}`: The command being executed
 

runce/cli.py

@@ -1,15 +1,18 @@
 import signal
 from argparse import ArgumentParser
-from subprocess import Popen, PIPE, run
-from typing import List, Dict, Any, Optional
+from shlex import join
 from sys import stderr, stdout
 from os import getpgid, killpg
-from shlex import join
 from shutil import copyfileobj
-from .spawn import Spawn
+from subprocess import Popen, PIPE, run
+from typing import Dict, Any
 from .utils import check_pid
 from .main import Main, flag, arg
 
+from .procdb import ProcessDB as Manager
+
+# from .spawn import Spawn as Manager
+
 
 class FormatDict(dict):
     def __missing__(self, key: str) -> str:
@@ -24,12 +27,9 @@ def __missing__(self, key: str) -> str:
                 return self["cmd"]
             return join(self["cmd"])
         elif key == "pid_status":
-            return "✅ Running" if check_pid(self["pid"]) else "👻 Absent"
+            return "✅ Live" if check_pid(self["pid"]) else "❌ Gone"
         raise KeyError(f"No {key!r}")
 
-    def __call__(self, *args: Any, **kwds: Any) -> Any:
-        return super().__call__(*args, **kwds)
-
 
 def format_prep(f: str):
 
@@ -57,7 +57,7 @@ def add_arguments(self, argp: ArgumentParser) -> None:
         return super().add_arguments(argp)
 
     def start(self) -> None:
-        sp = Spawn()
+        sp = Manager()
         for d in sp.find_names(self.ids, ambiguous, no_record):
             if check_pid(d["pid"]):
                 continue
@@ -81,7 +81,7 @@ def init_argparse(self, argp: ArgumentParser) -> None:
 
     def start(self) -> None:
         f = format_prep(self.format)
-        for d in Spawn().find_names(self.ids, ambiguous, no_record):
+        for d in Manager().find_names(self.ids, ambiguous, no_record):
             print(f(d))
 
 
@@ -97,7 +97,7 @@ def init_argparse(self, argp: ArgumentParser) -> None:
         return super().init_argparse(argp)
 
     def start(self) -> None:
-        sp = Spawn()
+        sp = Manager()
         if self.ids:
             for x in sp.find_names(self.ids, ambiguous, no_record):
                 pref = "❌ Error"
@@ -137,7 +137,7 @@ def start(self) -> None:
         j = 0
         out = "err" if self.err else "out"
 
-        for x in Spawn().find_names(self.ids, ambiguous, no_record):
+        for x in Manager().find_names(self.ids, ambiguous, no_record):
             if self.existing and not check_pid(x["pid"]):
                 continue
 
@@ -173,7 +173,7 @@ class Run(Main):
     def start(self) -> None:
         args = self.args
         name = self.run_id  # or " ".join(x for x in args)
-        sp = Spawn()
+        sp = Manager()
 
         # Check for existing process first
         e = sp.find_name(name) if name else None
@@ -209,7 +209,7 @@ class Ls(Main):
     format: str = flag(
         "f",
         "format of entry line",
-        default="{pid}\t{name}\t{pid_status}\t{elapsed}\t{command}",
+        default="{pid_status} {elapsed} {pid}\t{name}, {command}",
     )
 
     def init_argparse(self, argp: ArgumentParser) -> None:
@@ -218,9 +218,9 @@ def init_argparse(self, argp: ArgumentParser) -> None:
 
     def start(self) -> None:
         f = format_prep(self.format)
-        print("PID\tName\tStatus\tElapsed\tCommand")
-        print("───\t────\t──────\t───────\t───────")
-        for d in Spawn().all():
+        print("Status  Elapsed  PID\tName, Command")
+        print("─────── ──────── ────── ────────────")
+        for d in Manager().all():
             print(f(d))
 
 
@@ -235,13 +235,13 @@ def init_argparse(self, argp: ArgumentParser) -> None:
         return super().init_argparse(argp)
 
     def start(self) -> None:
-        sp = Spawn()
+        sp = Manager()
         if self.ids:
             for proc in sp.find_names(self.ids, ambiguous, no_record):
                 # First kill existing process
                 Kill().main(["--remove", proc["name"]])
                 # Then restart with same parameters
-                Run().main(["--id", proc["name"], "-t", self.tail, *proc["cmd"]])
+                Run().main(["--id", proc["name"], "-t", self.tail, "--", *proc["cmd"]])
 
 
 class App(Main):

runce/procdb.py

@@ -1,4 +1,3 @@
-# db.py
 import sqlite3
 from pathlib import Path
 from .spawn import Spawn
@@ -79,39 +78,6 @@ def all(self):
                     "started": row["started"],
                 }
 
-    # def get_process(self, name: str) -> Optional[Dict]:
-    #     """Fetch a process by name."""
-    #     with sqlite3.connect(self.db_path) as conn:
-    #         cursor = conn.execute(
-    #             "SELECT * FROM processes WHERE name = ? AND is_active = 1",
-    #             (name,),
-    #         )
-    #         row = cursor.fetchone()
-    #         if row:
-    #             return {
-    #                 "id": row[0],
-    #                 "pid": row[1],
-    #                 "name": row[2],
-    #                 "cmd": eval(row[3]),  # Convert JSON string back to list
-    #                 "stdout_path": row[4],
-    #                 "stderr_path": row[5],
-    #                 "started": row[6],
-    #             }
-    #     return None
-
-    # def kill_process(self, name: str) -> bool:
-    #     """Mark a process as inactive (killed)."""
-    #     with sqlite3.connect(self.db_path) as conn:
-    #         conn.execute(
-    #             "UPDATE processes SET is_active = 0 WHERE name = ?",
-    #             (name,),
-    #         )
-    #         return conn.total_changes > 0
-
-    # def cleanup(self) -> None:
-    #     """Remove all inactive processes."""
-    #     with sqlite3.connect(self.db_path) as conn:
-    #         conn.execute("DELETE FROM processes WHERE is_active = 0")
     def find_uuid(self, uuid: str):
         """Find a process by uuid"""
         with self.connect() as conn:
@@ -128,3 +94,12 @@ def find_uuid(self, uuid: str):
                     "err": row["err"],
                     "started": row["started"],
                 }
+
+    def drop(self, entry: dict[str, object], clean_up=True):
+        with self.connect() as conn:
+            conn.cursor().execute(
+                "DELETE FROM processes WHERE uuid = ?", (entry["uuid"],)
+            )
+            # print(f"Row with ID {entry["id"]} deleted successfully. {entry["name"]}")
+        super().drop(entry, clean_up)
+        assert self.find_uuid(entry["uuid"]) is None

runce/spawn.py

@@ -93,8 +93,9 @@ def spawn(
 
         process_info["base_name"] = base_name
         process_info["pid"] = Popen(cmd, **po_kwa).pid
-        # print("PI", process_info)
-        return self.add_process(process_info)
+        x = self.add_process(process_info)
+        # print("PI", x)
+        return x
 
     def add_process(self, process_info: dict[str, object]):
         """Insert a new process record."""

tests/test_cli.py

@@ -0,0 +1,112 @@
+from pathlib import Path
+from unittest import TestCase, main
+from runce.procdb import ProcessDB
+from runce.spawn import Spawn
+from runce.utils import slugify, get_base_name, look
+from subprocess import PIPE, run
+import re
+
+
+class TestUtils(TestCase):
+
+    def run_runce(self, *args, stdout_only=False):
+        """Helper to run python -m runce with stderr capture"""
+        cmd = ["python", "-m", "runce", *args]
+        print("RUN:", *cmd)
+        result = run(cmd, stdout=PIPE, stderr=PIPE, text=True)
+        o = result.stdout + result.stderr
+        print(o)
+        # if stdout_only:
+        #     return result.stdout
+        # Combine stdout and stderr for verification
+        return o
+
+    def test_split(self):
+        o = self.run_runce(
+            "run", "--split", "--", "bash", "-c", "echo -n 123; echo -n 456 >&2"
+        )
+        m = re.search(r"(?mx) \W+ Started: \W+ [^\)]+ \s+ \( [^\)]+ \) \s+ (.+)", o)
+        self.assertTrue(m)
+        n = m.group(1)
+        self.assertTrue(n)
+        o = self.run_runce("tail", "--header", "no", n)
+        # print(n)
+        self.assertEqual(o, "123")
+        o = self.run_runce("tail", "--err", "--header", "no", n)
+        self.assertEqual(o, "456")
+        self.run_runce("kill", n)
+        self.run_runce("clean", n)
+
+    def test_cli(self):
+        o = self.run_runce("run", "--id", "apple", "--", "bash", "-c", "sleep 10")
+        self.assertRegex(o, r"(?xim) \W+ started: \W+ .+ \W+ apple \W+")
+
+        o = self.run_runce(
+            "run",
+            "--split",
+            "--id",
+            "banana",
+            "--",
+            "bash",
+            "-c",
+            'for ((i=0; i<10; i++)); do echo "banana $i" >&2; sleep 2; done',
+        )
+        self.assertRegex(o, r"(?xim) \W+ started: \W+ .+ \W+ banana \W+")
+
+        o = self.run_runce(
+            "run",
+            "--id",
+            "pineapple",
+            "--",
+            "bash",
+            "-c",
+            'for ((i=0; i<10; i++)); do echo "pineapple $i"; sleep 2; done',
+        )
+        self.assertRegex(o, r"(?xim) \W+ started: \W+ .+ \W+ pineapple \W+")
+
+        for x in self.run_runce("status").strip().splitlines():
+            self.assertRegex(
+                x, r"(?xi) \W+ live \W+ .+ \W+ (?:apple|pineapple|banana) \W+"
+            )
+        o = self.run_runce("tail", "pineapple")
+        self.assertRegex(o, r"(?xim) \W+ pineapple \W+ \d+ \W+")
+
+        o = self.run_runce("tail", "--header", "no", "banana")
+        self.assertEqual(o, "")
+
+        # o = self.run_runce("tail", "--err", "banana")
+
+        o = self.run_runce("run", "--id", "banana", "--", "bash", "-c", "sleep 10")
+        self.assertRegex(o, r"(?xim) \W+ found \W+ .+ \W+ banana \W+")
+
+        o = self.run_runce("kill", "app")
+        self.assertRegex(o, r"(?xim) \W+ app \W+ is \W+ ambiguous")
+
+        o = self.run_runce("kill", "apple")
+        self.assertRegex(o, r"(?xim) killed .+ \W+ apple \W+")
+
+        for x in self.run_runce("kill", "lemon", "banana").strip().splitlines():
+            self.assertRegex(
+                x,
+                r"(?xim) \W+ no \s+ record .+ \W+ lemon \W+ | \W+ killed .+ \W+ banana \W+",
+            )
+        o = self.run_runce("restart", "banana")
+        # self.assertRegex()
+
+        for x in self.run_runce("status").strip().splitlines():
+            self.assertRegex(
+                x,
+                r"(?xi) \W+ live \W+ .+ \W+ (?:pineapple|banana) | gone \W+ .+ \W+ apple \W+",
+            )
+            pass
+
+        self.assertRegex(
+            self.run_runce("clean", "apple"), r"(?xim)^ \W+ Cleaning \W+ .+ \W+ apple"
+        )
+        self.run_runce("list")
+        for x in self.run_runce("kill", "--remove", "pi", "b").strip().splitlines():
+            self.assertRegex(x, r"(?xi) killed .+ \W+ (?:pineapple|banana) \W+")
+
+
+if __name__ == "__main__":
+    main()