cleepcli 1.46.0__tar.gz → 1.48.0__tar.gz

{cleepcli-1.46.0 → cleepcli-1.48.0}/MANIFEST.in

@@ -7,3 +7,4 @@ include setup.cfg
 include MANIFEST.in
 recursive-include bin *
 recursive-include cleepcli *.py
+recursive-include cleepcli/systemd *

{cleepcli-1.46.0/cleepcli.egg-info → cleepcli-1.48.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cleepcli
-Version: 1.46.0
+Version: 1.48.0
 Summary: Cleep-cli helps developers to build great Cleep applications from command line.
 Home-page: https://github.com/CleepDevice/cleep-cli
 Author: Tanguy Bonneau
@@ -61,7 +61,9 @@ This utility helps developers to build Cleep applications providing some useful
     - `modcheckscripts` to check app scripts files
     - `modcheckcode` to check backend code quality (run pylint)
 - Watch commands:
-    - `watch` to watch for repository filesystem changes and automatically update files on execution folders. It also restart backend or/and frontend according to changes.
+    - `watch` to watch for repository filesystem changes and automatically update files on execution folders. It also restart backend or/and frontend according to changes (catch-up sync on start).
+    - `watchsvc` to install/enable/disable/restart the durable `cleep-watch` systemd unit (runs `watch` outside `cleep.service`).
+    - `syncall` to force a one-shot sync of core + all modules (same catch-up as watch start).
 - Misc commands:
     - `version` to get cleep-cli version
 
@@ -85,9 +87,23 @@ Execute this command to get help on this cli:
 
 ## Watch usage
 
-Launch `watch` cli command to monitor changes on "/root/cleep-dev" directory after getting official Cleep repository using `coreget` command.
+Preferred: let the CLI own the durable systemd unit:
 
-Then open your favorite editor on your development computer, configure a remote sync plugin to push local changes on your raspberry pi then cleep-cli will synchronize sources on Cleep execution environment and restart application automatically.
+```
+cleep-cli watchsvc install
+cleep-cli watchsvc enable
+```
+
+The unit runs `cleep-cli watch`, survives `systemctl restart cleep`, and on each start performs a catch-up `syncall` so files written while the watcher was down are applied.
+
+Manual one-shot resync (when the UI looks stale):
+
+```
+cleep-cli syncall
+cleep-cli watchsvc restart   # catch-up again + resume watch
+```
+
+You can still run `cleep-cli watch` in a terminal for debugging. Push sources to `/root/cleep-dev` (CleepDesktop developer sync or SFTP); the watcher copies them into the execution folders and restarts backend/frontend as needed.
 
 ### Paths
 

{cleepcli-1.46.0 → cleepcli-1.48.0}/README.md

@@ -25,7 +25,9 @@ This utility helps developers to build Cleep applications providing some useful
     - `modcheckscripts` to check app scripts files
     - `modcheckcode` to check backend code quality (run pylint)
 - Watch commands:
-    - `watch` to watch for repository filesystem changes and automatically update files on execution folders. It also restart backend or/and frontend according to changes.
+    - `watch` to watch for repository filesystem changes and automatically update files on execution folders. It also restart backend or/and frontend according to changes (catch-up sync on start).
+    - `watchsvc` to install/enable/disable/restart the durable `cleep-watch` systemd unit (runs `watch` outside `cleep.service`).
+    - `syncall` to force a one-shot sync of core + all modules (same catch-up as watch start).
 - Misc commands:
     - `version` to get cleep-cli version
 
@@ -49,9 +51,23 @@ Execute this command to get help on this cli:
 
 ## Watch usage
 
-Launch `watch` cli command to monitor changes on "/root/cleep-dev" directory after getting official Cleep repository using `coreget` command.
+Preferred: let the CLI own the durable systemd unit:
 
-Then open your favorite editor on your development computer, configure a remote sync plugin to push local changes on your raspberry pi then cleep-cli will synchronize sources on Cleep execution environment and restart application automatically.
+```
+cleep-cli watchsvc install
+cleep-cli watchsvc enable
+```
+
+The unit runs `cleep-cli watch`, survives `systemctl restart cleep`, and on each start performs a catch-up `syncall` so files written while the watcher was down are applied.
+
+Manual one-shot resync (when the UI looks stale):
+
+```
+cleep-cli syncall
+cleep-cli watchsvc restart   # catch-up again + resume watch
+```
+
+You can still run `cleep-cli watch` in a terminal for debugging. Push sources to `/root/cleep-dev` (CleepDesktop developer sync or SFTP); the watcher copies them into the execution folders and restarts backend/frontend as needed.
 
 ### Paths
 

{cleepcli-1.46.0 → cleepcli-1.48.0}/bin/ccli

@@ -17,6 +17,7 @@ from cleepcli.git import Git
 from cleepcli.module import Module
 from cleepcli.file import File
 from cleepcli.watch import CleepWatchdog
+from cleepcli.watchsvc import WatchService
 from cleepcli.test import Test, is_file_coverage_valid
 from cleepcli.package import Package
 from cleepcli.docs import Docs
@@ -108,6 +109,18 @@ def coresync():
         sys.exit(1)
     logging.info('Done')
 
+@core.command()
+def syncall():
+    """
+    Synchronize core and all modules from /root/cleep-dev to execution folders.
+
+    Same catch-up used when cleep-watch.service starts. Safe one-shot resync when
+    the UI looks stale: run this, then reload the device page.
+    """
+    f = File()
+    if not f.sync_all():
+        sys.exit(1)
+
 @core.command()
 @click.option('--coverage', is_flag=True, help='Display coverage report.')
 @click.option('--output', is_flag=True, help='Display tests output.')
@@ -358,9 +371,13 @@ def watchdog():
 @click.option('--quiet', is_flag=True, help='Disable logging.')
 @click.option('--loglevel', default=logging.INFO, help='Logging level (10=DEBUG, 20=INFO, 30=WARN, 40=ERROR).')
 @click.option('--rpc-url', default='https://127.0.0.1:443', help='Cleep RPC url (ex https://ip|host:port')
-def watch(quiet, loglevel, rpc_url):
+@click.option('--skip-catchup', is_flag=True, help='Do not syncall before watching (not recommended).')
+def watch(quiet, loglevel, rpc_url, skip_catchup):
     """
-    Start watchdog that monitors filesystem changes on Cleep sources
+    Start watchdog that monitors filesystem changes on Cleep sources.
+
+    Prefer managing the durable unit with watchsvc (survives Cleep restarts).
+    On start, syncs core + all modules once unless --skip-catchup is set.
     """
     if logging.getLogger().getEffectiveLevel() == logging.DEBUG:
         # do not overwrite root logger level if configured to DEBUG (dev mode)
@@ -369,13 +386,51 @@ def watch(quiet, loglevel, rpc_url):
         logging.disable(logging.CRITICAL)
     else:
         logging.getLogger().setLevel(loglevel)
-        
-    w = CleepWatchdog(rpc_url)
+
+    w = CleepWatchdog(rpc_url, catch_up=not skip_catchup)
     res = w.watch()
 
     if not res:
         sys.exit(1)
 
+@watchdog.command('watchsvc')
+@click.argument(
+    'action',
+    type=click.Choice(
+        ['install', 'uninstall', 'enable', 'disable', 'start', 'stop', 'restart', 'status']
+    ),
+)
+def watchsvc_cmd(action):
+    """
+    Manage the durable cleep-watch systemd unit.
+
+    ACTION is one of: install, uninstall, enable, disable, start, stop, restart, status.
+
+    The unit runs ``cleep-cli watch`` outside of cleep.service. Typical setup::
+
+        cleep-cli watchsvc install
+        cleep-cli watchsvc enable
+    """
+    svc = WatchService()
+    handlers = {
+        'install': svc.install,
+        'uninstall': svc.uninstall,
+        'enable': svc.enable,
+        'disable': svc.disable,
+        'start': svc.start,
+        'stop': svc.stop,
+        'restart': svc.restart,
+    }
+    if action == 'status':
+        status = svc.status()
+        logging.info(status)
+        if status != 'active':
+            sys.exit(1)
+        return
+
+    if not handlers[action]():
+        sys.exit(1)
+
 @click.group()
 def test():
     pass

{cleepcli-1.46.0 → cleepcli-1.48.0}/bin/cleep-cli

@@ -17,6 +17,7 @@ from cleepcli.git import Git
 from cleepcli.module import Module
 from cleepcli.file import File
 from cleepcli.watch import CleepWatchdog
+from cleepcli.watchsvc import WatchService
 from cleepcli.test import Test, is_file_coverage_valid
 from cleepcli.package import Package
 from cleepcli.docs import Docs
@@ -108,6 +109,18 @@ def coresync():
         sys.exit(1)
     logging.info('Done')
 
+@core.command()
+def syncall():
+    """
+    Synchronize core and all modules from /root/cleep-dev to execution folders.
+
+    Same catch-up used when cleep-watch.service starts. Safe one-shot resync when
+    the UI looks stale: run this, then reload the device page.
+    """
+    f = File()
+    if not f.sync_all():
+        sys.exit(1)
+
 @core.command()
 @click.option('--coverage', is_flag=True, help='Display coverage report.')
 @click.option('--output', is_flag=True, help='Display tests output.')
@@ -358,9 +371,13 @@ def watchdog():
 @click.option('--quiet', is_flag=True, help='Disable logging.')
 @click.option('--loglevel', default=logging.INFO, help='Logging level (10=DEBUG, 20=INFO, 30=WARN, 40=ERROR).')
 @click.option('--rpc-url', default='https://127.0.0.1:443', help='Cleep RPC url (ex https://ip|host:port')
-def watch(quiet, loglevel, rpc_url):
+@click.option('--skip-catchup', is_flag=True, help='Do not syncall before watching (not recommended).')
+def watch(quiet, loglevel, rpc_url, skip_catchup):
     """
-    Start watchdog that monitors filesystem changes on Cleep sources
+    Start watchdog that monitors filesystem changes on Cleep sources.
+
+    Prefer managing the durable unit with watchsvc (survives Cleep restarts).
+    On start, syncs core + all modules once unless --skip-catchup is set.
     """
     if logging.getLogger().getEffectiveLevel() == logging.DEBUG:
         # do not overwrite root logger level if configured to DEBUG (dev mode)
@@ -369,13 +386,51 @@ def watch(quiet, loglevel, rpc_url):
         logging.disable(logging.CRITICAL)
     else:
         logging.getLogger().setLevel(loglevel)
-        
-    w = CleepWatchdog(rpc_url)
+
+    w = CleepWatchdog(rpc_url, catch_up=not skip_catchup)
     res = w.watch()
 
     if not res:
         sys.exit(1)
 
+@watchdog.command('watchsvc')
+@click.argument(
+    'action',
+    type=click.Choice(
+        ['install', 'uninstall', 'enable', 'disable', 'start', 'stop', 'restart', 'status']
+    ),
+)
+def watchsvc_cmd(action):
+    """
+    Manage the durable cleep-watch systemd unit.
+
+    ACTION is one of: install, uninstall, enable, disable, start, stop, restart, status.
+
+    The unit runs ``cleep-cli watch`` outside of cleep.service. Typical setup::
+
+        cleep-cli watchsvc install
+        cleep-cli watchsvc enable
+    """
+    svc = WatchService()
+    handlers = {
+        'install': svc.install,
+        'uninstall': svc.uninstall,
+        'enable': svc.enable,
+        'disable': svc.disable,
+        'start': svc.start,
+        'stop': svc.stop,
+        'restart': svc.restart,
+    }
+    if action == 'status':
+        status = svc.status()
+        logging.info(status)
+        if status != 'active':
+            sys.exit(1)
+        return
+
+    if not handlers[action]():
+        sys.exit(1)
+
 @click.group()
 def test():
     pass

{cleepcli-1.46.0 → cleepcli-1.48.0}/cleepcli/check.py

@@ -1497,6 +1497,50 @@ overgeneral-exceptions=Exception
         """
         return self._check_module_tree(module_name, "asset")
 
+    def check_firmwares(self, module_name):
+        """
+        Validate optional ``firmwares/`` zip+sidecar ``.manifest`` pairs and list
+        files for packaging (see ``cleep.libs.internals.firmware_manifest``).
+
+        Returns:
+            dict: errors / warnings / files (same shape as check_scripts)
+        """
+        if not os.path.exists(os.path.join(config.MODULES_DST, module_name)):
+            raise Exception('Module "%s" does not exist' % module_name)
+
+        firmwares_path = os.path.join(config.MODULES_SRC, module_name, "firmwares")
+        out = {
+            "errors": [],
+            "warnings": [],
+            "files": [],
+        }
+        if not os.path.isdir(firmwares_path):
+            return out
+
+        try:
+            from cleep.libs.internals.firmware_manifest import (
+                FirmwareManifestError,
+                scan_firmwares_dir,
+            )
+        except ImportError:
+            out["errors"].append(
+                "Unable to import cleep.libs.internals.firmware_manifest "
+                "(is Cleep core available on PYTHONPATH?)"
+            )
+            return out
+
+        try:
+            scan_firmwares_dir(firmwares_path)
+        except FirmwareManifestError as error:
+            out["errors"].append(str(error))
+            return out
+
+        # Include valid pairs in the package file list
+        tree = self._check_module_tree(module_name, "firmwares")
+        out["files"] = tree["files"]
+        out["warnings"] = tree["warnings"]
+        return out
+
     def check_tests(self, module_name):
         """
         Check test files

{cleepcli-1.46.0 → cleepcli-1.48.0}/cleepcli/file.py

@@ -60,6 +60,51 @@ rsync -av "%(REPO_DIR)s/medias/sounds" "%(MEDIA_DST)s/sounds/" --delete
 
         return True
 
+    def list_modules(self):
+        """
+        List module folder names under MODULES_SRC (skips hidden dirs).
+
+        Returns:
+            list: sorted module names
+        """
+        if not os.path.isdir(config.MODULES_SRC):
+            return []
+        names = []
+        try:
+            for name in os.listdir(config.MODULES_SRC):
+                if name.startswith("."):
+                    continue
+                path = os.path.join(config.MODULES_SRC, name)
+                if os.path.isdir(path):
+                    names.append(name)
+        except OSError as error:
+            self.logger.error("Unable to list modules: %s", error)
+            return []
+        return sorted(names)
+
+    def sync_all(self):
+        """
+        Synchronize core and every module from REPO_DIR to execution folders.
+
+        Used as watch catch-up on start and by the ``syncall`` CLI command so a
+        full resync is always one explicit action away.
+
+        Returns:
+            bool: True if every sync succeeded
+        """
+        self.logger.info("Synchronizing core sources...")
+        if not self.core_sync():
+            return False
+
+        modules = self.list_modules()
+        for module_name in modules:
+            self.logger.info('Synchronizing module "%s" sources...', module_name)
+            if not self.module_sync(module_name):
+                return False
+
+        self.logger.info("Sync all done (%d module(s))", len(modules))
+        return True
+
     def module_sync(self, module_name, backend=True, frontend=True, scripts=True):
         """
         Copy specified module content to valid execution location

{cleepcli-1.46.0 → cleepcli-1.48.0}/cleepcli/package.py

@@ -516,6 +516,12 @@ sha256sum $DEB > $SHA256
                 "Error in asset/. Fix it before packaging application: %s"
                 % data_asset["errors"]
             )
+        data_firmwares = check.check_firmwares(module_name)
+        if len(data_firmwares["errors"]) > 0:
+            raise Exception(
+                "Error in firmwares/. Fix it before packaging application: %s"
+                % data_firmwares["errors"]
+            )
         data_tests = check.check_tests(module_name)
         if len(data_tests["errors"]) > 0:
             raise Exception(
@@ -629,6 +635,10 @@ sha256sum $DEB > $SHA256
         for a_file in data_asset["files"]:
             archive.write(a_file["fullpath"], a_file["path"])
 
+        # add firmwares/ (zip + sidecar .manifest; installer copies to APP_FIRMWARE)
+        for a_file in data_firmwares["files"]:
+            archive.write(a_file["fullpath"], a_file["path"])
+
         # add module.json
         archive.write(module_json, "module.json")
 

cleepcli-1.48.0/cleepcli/systemd/cleep-watch.service

@@ -0,0 +1,18 @@
+[Unit]
+Description=Cleep development source watcher (cleep-cli watch)
+Documentation=https://github.com/CleepDevice/cleep-cli
+# Independent from cleep.service so backend restarts do not kill the watcher
+# mid-sync (Desktop writes would otherwise be missed until the next edit).
+After=network-online.target
+Wants=network-online.target
+
+[Service]
+Type=simple
+ExecStart=/usr/local/bin/cleep-cli watch --loglevel=20
+Restart=always
+RestartSec=3
+# Allow a long catch-up sync on start before the main loop
+TimeoutStartSec=180
+
+[Install]
+WantedBy=multi-user.target

{cleepcli-1.46.0 → cleepcli-1.48.0}/cleepcli/version.py

@@ -1,4 +1,4 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 
-VERSION = "1.46.0"
+VERSION = "1.48.0"

{cleepcli-1.46.0 → cleepcli-1.48.0}/cleepcli/watch.py

@@ -18,6 +18,7 @@ from watchdog.events import (
 import watchdog.events as events
 from .cleepapi import CleepApi
 from .file import File
+from .watchsvc import WATCH_SERVICE
 
 _WATCHED_EVENT_TYPES = (
     EVENT_TYPE_CREATED,
@@ -206,6 +207,11 @@ class CleepHandler(FileSystemEventHandler):
     REJECTED_FILENAMES = [
         "4913",  # vim furtive temp file to check user permissions
         ".gitignore",
+        # Module-root docs are not synced by module_sync; ignore to avoid noise.
+        "CHANGELOG.md",
+        "README.md",
+        "LICENSE",
+        "COPYING",
     ]
     REJECTED_EXTENSIONS = [
         ".swp",  # vim
@@ -521,22 +527,24 @@ class CleepWatchdog:
     Cleep core and module watchdog
     """
 
-    def __init__(self, rpc_url):
+    def __init__(self, rpc_url, catch_up=True):
         """
         Constructor
 
         Args:
             rpc_url (str): Cleep RPC url
+            catch_up (bool): when True, sync core + all modules before watching
+                so files written while the watcher was down are not missed
         """
         self.logger = logging.getLogger(self.__class__.__name__)
         self.actions_executor = ActionsExecutor(rpc_url)
+        self.catch_up = catch_up
 
     def watch(self):
         """
         Start watchdog that monitors filesystem changes on Cleep sources
         """
         path = "%s/" % config.REPO_DIR
-        self.actions_executor.start()
 
         if not os.path.exists(path):
             self.logger.error(
@@ -544,6 +552,20 @@ class CleepWatchdog:
             )
             return False
 
+        # Catch-up before inotify: Desktop (or editors) may have written while
+        # this process was stopped (cleep restart, create-app pause, boot).
+        if self.catch_up:
+            self.logger.info("Catch-up sync before watching...")
+            if not File().sync_all():
+                self.logger.error(
+                    "Catch-up sync failed; fix errors then retry "
+                    "(cleep-cli syncall / systemctl restart %s)",
+                    WATCH_SERVICE,
+                )
+                return False
+
+        self.actions_executor.start()
+
         event_handler = CleepHandler(self.actions_executor)
         observer = Observer()
         event_handler.observer = observer

cleepcli-1.48.0/cleepcli/watchsvc.py

@@ -0,0 +1,214 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+Manage the durable cleep-watch systemd unit.
+
+The unit runs ``cleep-cli watch`` outside of cleep.service so backend restarts
+do not kill the watcher mid-sync.
+"""
+
+import logging
+import os
+import shutil
+
+from .console import Console
+
+WATCH_SERVICE = "cleep-watch.service"
+WATCH_UNIT_DST = "/lib/systemd/system/%s" % WATCH_SERVICE
+
+
+def bundled_unit_path():
+    """
+    Path to the unit file shipped inside the cleepcli package.
+
+    Returns:
+        str: absolute path to cleep-watch.service
+    """
+    return os.path.join(os.path.dirname(__file__), "systemd", WATCH_SERVICE)
+
+
+class WatchService:
+    """
+    Install / enable / control cleep-watch.service via systemctl.
+    """
+
+    def __init__(self):
+        self.logger = logging.getLogger(self.__class__.__name__)
+        self.console = Console()
+
+    def _systemctl(self, *args, timeout=60.0):
+        cmd = "/bin/systemctl " + " ".join(args)
+        self.logger.debug("systemctl cmd: %s", cmd)
+        return self.console.command(cmd, timeout)
+
+    def _ok(self, resp):
+        return not resp.get("killed") and resp.get("returncode", 1) == 0
+
+    def _daemon_reload(self):
+        return self._ok(self._systemctl("daemon-reload"))
+
+    def install(self):
+        """
+        Copy the bundled unit to systemd and reload the daemon.
+
+        Returns:
+            bool: True on success
+        """
+        src = bundled_unit_path()
+        if not os.path.isfile(src):
+            self.logger.error("Bundled unit not found: %s", src)
+            return False
+        try:
+            os.makedirs(os.path.dirname(WATCH_UNIT_DST), exist_ok=True)
+            shutil.copyfile(src, WATCH_UNIT_DST)
+        except OSError as error:
+            self.logger.error("Unable to install %s: %s", WATCH_UNIT_DST, error)
+            return False
+        if not self._daemon_reload():
+            self.logger.error("systemctl daemon-reload failed after install")
+            return False
+        self.logger.info("Installed %s", WATCH_UNIT_DST)
+        return True
+
+    def uninstall(self):
+        """
+        Disable the unit, remove the unit file, reload systemd.
+
+        Returns:
+            bool: True on success (missing unit is OK)
+        """
+        self.disable()
+        try:
+            if os.path.isfile(WATCH_UNIT_DST):
+                os.remove(WATCH_UNIT_DST)
+                self.logger.info("Removed %s", WATCH_UNIT_DST)
+        except OSError as error:
+            self.logger.error("Unable to remove %s: %s", WATCH_UNIT_DST, error)
+            return False
+        if not self._daemon_reload():
+            self.logger.error("systemctl daemon-reload failed after uninstall")
+            return False
+        return True
+
+    def enable(self):
+        """
+        Enable and start the unit (installs the unit file first if missing).
+
+        Returns:
+            bool: True on success
+        """
+        if not os.path.isfile(WATCH_UNIT_DST):
+            if not self.install():
+                return False
+        resp = self._systemctl("enable", "--now", WATCH_SERVICE)
+        if not self._ok(resp):
+            self.logger.error(
+                "Unable to enable %s: %s %s",
+                WATCH_SERVICE,
+                resp.get("stdout"),
+                resp.get("stderr"),
+            )
+            return False
+        return self.is_active()
+
+    def disable(self):
+        """
+        Disable and stop the unit.
+
+        Returns:
+            bool: True on success (or if unit was not installed)
+        """
+        if not os.path.isfile(WATCH_UNIT_DST):
+            return True
+        resp = self._systemctl("disable", "--now", WATCH_SERVICE)
+        if not self._ok(resp):
+            # Unit may already be inactive/disabled
+            self.logger.debug(
+                "disable --now %s: %s %s",
+                WATCH_SERVICE,
+                resp.get("stdout"),
+                resp.get("stderr"),
+            )
+        return True
+
+    def start(self):
+        """
+        Start the unit (catch-up sync runs on ExecStart).
+
+        Returns:
+            bool: True on success
+        """
+        if not os.path.isfile(WATCH_UNIT_DST):
+            if not self.install():
+                return False
+        resp = self._systemctl("start", WATCH_SERVICE)
+        if not self._ok(resp):
+            self.logger.error(
+                "Unable to start %s: %s %s",
+                WATCH_SERVICE,
+                resp.get("stdout"),
+                resp.get("stderr"),
+            )
+            return False
+        return True
+
+    def stop(self):
+        """
+        Stop the unit.
+
+        Returns:
+            bool: True on success
+        """
+        if not os.path.isfile(WATCH_UNIT_DST):
+            return True
+        resp = self._systemctl("stop", WATCH_SERVICE)
+        if not self._ok(resp):
+            self.logger.error(
+                "Unable to stop %s: %s %s",
+                WATCH_SERVICE,
+                resp.get("stdout"),
+                resp.get("stderr"),
+            )
+            return False
+        return True
+
+    def restart(self):
+        """
+        Restart the unit (re-runs catch-up sync on start).
+
+        Returns:
+            bool: True on success
+        """
+        if not os.path.isfile(WATCH_UNIT_DST):
+            return self.enable()
+        resp = self._systemctl("restart", WATCH_SERVICE, timeout=180.0)
+        if not self._ok(resp):
+            self.logger.error(
+                "Unable to restart %s: %s %s",
+                WATCH_SERVICE,
+                resp.get("stdout"),
+                resp.get("stderr"),
+            )
+            return False
+        return True
+
+    def is_active(self):
+        """
+        Return True if the unit is active.
+        """
+        resp = self._systemctl("is-active", WATCH_SERVICE, timeout=5.0)
+        active = "".join(resp.get("stdout") or []).strip()
+        return active == "active"
+
+    def status(self):
+        """
+        Print / return a short status string for the unit.
+
+        Returns:
+            str: systemctl is-active output (or "not-installed")
+        """
+        if not os.path.isfile(WATCH_UNIT_DST):
+            return "not-installed"
+        resp = self._systemctl("is-active", WATCH_SERVICE, timeout=5.0)
+        return "".join(resp.get("stdout") or []).strip() or "unknown"

{cleepcli-1.46.0 → cleepcli-1.48.0/cleepcli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cleepcli
-Version: 1.46.0
+Version: 1.48.0
 Summary: Cleep-cli helps developers to build great Cleep applications from command line.
 Home-page: https://github.com/CleepDevice/cleep-cli
 Author: Tanguy Bonneau
@@ -61,7 +61,9 @@ This utility helps developers to build Cleep applications providing some useful
     - `modcheckscripts` to check app scripts files
     - `modcheckcode` to check backend code quality (run pylint)
 - Watch commands:
-    - `watch` to watch for repository filesystem changes and automatically update files on execution folders. It also restart backend or/and frontend according to changes.
+    - `watch` to watch for repository filesystem changes and automatically update files on execution folders. It also restart backend or/and frontend according to changes (catch-up sync on start).
+    - `watchsvc` to install/enable/disable/restart the durable `cleep-watch` systemd unit (runs `watch` outside `cleep.service`).
+    - `syncall` to force a one-shot sync of core + all modules (same catch-up as watch start).
 - Misc commands:
     - `version` to get cleep-cli version
 
@@ -85,9 +87,23 @@ Execute this command to get help on this cli:
 
 ## Watch usage
 
-Launch `watch` cli command to monitor changes on "/root/cleep-dev" directory after getting official Cleep repository using `coreget` command.
+Preferred: let the CLI own the durable systemd unit:
 
-Then open your favorite editor on your development computer, configure a remote sync plugin to push local changes on your raspberry pi then cleep-cli will synchronize sources on Cleep execution environment and restart application automatically.
+```
+cleep-cli watchsvc install
+cleep-cli watchsvc enable
+```
+
+The unit runs `cleep-cli watch`, survives `systemctl restart cleep`, and on each start performs a catch-up `syncall` so files written while the watcher was down are applied.
+
+Manual one-shot resync (when the UI looks stale):
+
+```
+cleep-cli syncall
+cleep-cli watchsvc restart   # catch-up again + resume watch
+```
+
+You can still run `cleep-cli watch` in a terminal for debugging. Push sources to `/root/cleep-dev` (CleepDesktop developer sync or SFTP); the watcher copies them into the execution folders and restarts backend/frontend as needed.
 
 ### Paths
 

{cleepcli-1.46.0 → cleepcli-1.48.0}/cleepcli.egg-info/SOURCES.txt

@@ -22,15 +22,19 @@ cleepcli/test.py
 cleepcli/tools.py
 cleepcli/version.py
 cleepcli/watch.py
+cleepcli/watchsvc.py
 cleepcli.egg-info/PKG-INFO
 cleepcli.egg-info/SOURCES.txt
 cleepcli.egg-info/dependency_links.txt
 cleepcli.egg-info/requires.txt
 cleepcli.egg-info/top_level.txt
+cleepcli/systemd/cleep-watch.service
 tests/test_check.py
 tests/test_config.py
 tests/test_console.py
 tests/test_coverage.py
 tests/test_docs_breaking.py
+tests/test_file_sync_all.py
 tests/test_module_scaffold.py
-tests/test_watch.py
+tests/test_watch.py
+tests/test_watchsvc.py

{cleepcli-1.46.0 → cleepcli-1.48.0}/setup.py

@@ -39,6 +39,7 @@ setup(
     maintainer_email="tanguy.bonneau@gmail.com",
     url="https://github.com/CleepDevice/cleep-cli",
     packages=["cleepcli"],
+    package_data={"cleepcli": ["systemd/cleep-watch.service"]},
     include_package_data=True,
     install_requires=get_requirements(),
     python_requires=">=3.7",

cleepcli-1.48.0/tests/test_file_sync_all.py

@@ -0,0 +1,91 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+import os
+import shutil
+import tempfile
+
+from unittest.mock import Mock, patch
+
+from cleepcli import config
+from cleepcli.file import File
+
+
+def test_list_modules_sorted():
+    repo = tempfile.mkdtemp()
+    try:
+        modules = os.path.join(repo, "modules")
+        os.makedirs(os.path.join(modules, "zeta"))
+        os.makedirs(os.path.join(modules, "alpha"))
+        os.makedirs(os.path.join(modules, ".hidden"))
+        open(os.path.join(modules, "file.txt"), "w", encoding="utf-8").close()
+
+        with patch.object(config, "MODULES_SRC", modules):
+            assert File().list_modules() == ["alpha", "zeta"]
+    finally:
+        shutil.rmtree(repo)
+
+
+def test_sync_all_runs_core_then_modules():
+    f = File()
+    f.core_sync = Mock(return_value=True)
+    f.module_sync = Mock(return_value=True)
+    f.list_modules = Mock(return_value=["audio", "developer"])
+
+    assert f.sync_all() is True
+    f.core_sync.assert_called_once_with()
+    assert f.module_sync.call_args_list[0].args[0] == "audio"
+    assert f.module_sync.call_args_list[1].args[0] == "developer"
+
+
+def test_sync_all_stops_on_core_failure():
+    f = File()
+    f.core_sync = Mock(return_value=False)
+    f.module_sync = Mock(return_value=True)
+    f.list_modules = Mock(return_value=["audio"])
+
+    assert f.sync_all() is False
+    f.module_sync.assert_not_called()
+
+
+def test_watch_catch_up_calls_sync_all():
+    from cleepcli.watch import CleepWatchdog
+
+    with patch("cleepcli.watch.File") as file_cls, patch(
+        "cleepcli.watch.os.path.exists", return_value=True
+    ), patch("cleepcli.watch.Observer"), patch(
+        "cleepcli.watch.CleepHandler"
+    ) as handler_cls, patch(
+        "cleepcli.watch.ActionsExecutor"
+    ), patch(
+        "cleepcli.watch.time.sleep", side_effect=KeyboardInterrupt
+    ):
+        file_cls.return_value.sync_all.return_value = True
+        handler = handler_cls.return_value
+        handler._watched = {"/tmp"}
+        handler.schedule_all = Mock()
+
+        watchdog = CleepWatchdog("https://127.0.0.1:443", catch_up=True)
+        assert watchdog.watch() is True
+        file_cls.return_value.sync_all.assert_called_once_with()
+
+
+def test_watch_skip_catch_up():
+    from cleepcli.watch import CleepWatchdog
+
+    with patch("cleepcli.watch.File") as file_cls, patch(
+        "cleepcli.watch.os.path.exists", return_value=True
+    ), patch("cleepcli.watch.Observer"), patch(
+        "cleepcli.watch.CleepHandler"
+    ) as handler_cls, patch(
+        "cleepcli.watch.ActionsExecutor"
+    ), patch(
+        "cleepcli.watch.time.sleep", side_effect=KeyboardInterrupt
+    ):
+        handler = handler_cls.return_value
+        handler._watched = {"/tmp"}
+        handler.schedule_all = Mock()
+
+        watchdog = CleepWatchdog("https://127.0.0.1:443", catch_up=False)
+        assert watchdog.watch() is True
+        file_cls.return_value.sync_all.assert_not_called()

{cleepcli-1.46.0 → cleepcli-1.48.0}/tests/test_watch.py

@@ -131,6 +131,13 @@ def test_module_frontend_is_queued(handler):
     )
 
 
+def test_module_changelog_is_ignored(handler):
+    h, executor = handler
+    path = os.path.join(config.MODULES_SRC, "audio", "CHANGELOG.md")
+    h.on_any_event(FileModifiedEvent(path))
+    executor.note_change.assert_not_called()
+
+
 def test_created_git_directory_is_not_watched(handler):
     h, executor = handler
     h.observer = Mock()

cleepcli-1.48.0/tests/test_watchsvc.py

@@ -0,0 +1,57 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+import os
+from unittest.mock import Mock, patch
+
+from cleepcli.watchsvc import WatchService, WATCH_UNIT_DST, bundled_unit_path
+
+
+def test_bundled_unit_path_exists():
+    assert os.path.isfile(bundled_unit_path())
+
+
+def test_install_copies_unit_and_reloads():
+    svc = WatchService()
+    svc.console = Mock()
+    svc.console.command.return_value = {"returncode": 0, "stdout": "", "stderr": ""}
+
+    with patch("cleepcli.watchsvc.shutil.copyfile") as copyfile, patch(
+        "cleepcli.watchsvc.os.makedirs"
+    ), patch("cleepcli.watchsvc.os.path.isfile", return_value=True):
+        assert svc.install() is True
+        copyfile.assert_called_once()
+        assert copyfile.call_args.args[1] == WATCH_UNIT_DST
+        svc.console.command.assert_called_with(
+            "/bin/systemctl daemon-reload", 60.0
+        )
+
+
+def test_enable_installs_when_missing():
+    svc = WatchService()
+    svc.install = Mock(return_value=True)
+    svc.is_active = Mock(return_value=True)
+    svc.console = Mock()
+    svc.console.command.return_value = {"returncode": 0, "stdout": "", "stderr": ""}
+
+    with patch("cleepcli.watchsvc.os.path.isfile", return_value=False):
+        assert svc.enable() is True
+    svc.install.assert_called_once_with()
+
+
+def test_status_not_installed():
+    svc = WatchService()
+    with patch("cleepcli.watchsvc.os.path.isfile", return_value=False):
+        assert svc.status() == "not-installed"
+
+
+def test_status_active():
+    svc = WatchService()
+    svc.console = Mock()
+    svc.console.command.return_value = {
+        "returncode": 0,
+        "stdout": ["active"],
+        "stderr": "",
+    }
+    with patch("cleepcli.watchsvc.os.path.isfile", return_value=True):
+        assert svc.status() == "active"