safekeep 0.3.0__tar.gz → 0.4.0__tar.gz

{safekeep-0.3.0/safekeep.egg-info → safekeep-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: safekeep
-Version: 0.3.0
+Version: 0.4.0
 Summary: Selective always-on backups for macOS and Linux: fswatch-driven copy of allow-listed files, never deletes
 License-Expression: MIT
 Project-URL: Repository, https://github.com/foxhound87/safekeep

{safekeep-0.3.0 → safekeep-0.4.0}/safekeep/__init__.py

@@ -3,4 +3,4 @@ import logging
 
 logging.getLogger('safekeep').addHandler(logging.NullHandler())
 
-__version__ = '0.3.0'
+__version__ = '0.4.0'

{safekeep-0.3.0 → safekeep-0.4.0}/safekeep/cli.py

@@ -14,11 +14,17 @@ from safekeep.copier import TMP_INFIX
 from safekeep.daemon import Daemon, setup_logging
 from safekeep.platform import (
     INOTIFY_MIN_WATCHES,
+    LOG_PATH,
     fswatch_monitor,
     inotify_limit,
     install_hint,
     is_darwin,
     is_linux,
+    is_wsl,
+    linger_enabled,
+    recent_permission_errors,
+    systemd_user_available,
+    wsl_distro,
 )
 from safekeep.volumes import dest_state
 
@@ -54,7 +60,8 @@ def build_parser():
                    help='config, progetti e stato delle dest — sola lettura')
     sub.add_parser('doctor', parents=[common],
                    help='diagnostica: config, fswatch + monitor di piattaforma, python, '
-                        'TCC/plist (macOS), inotify/systemd (Linux) — exit ≠ 0 se un check '
+                        'errori di permesso recenti nel log, TCC/plist (macOS), '
+                        'inotify/systemd/linger (Linux) — exit ≠ 0 se un check '
                         'fatale fallisce')
     return parser
 
@@ -226,6 +233,37 @@ def cmd_doctor(args):
     out(sys.version_info >= (3, 9),
         f'python {sys.version.split()[0]} (≥ 3.9)', is_fatal=True)
 
+    # Errori di permesso recenti nel log corrente (SPEC.md §14.4): sintomo
+    # delle ultime 24h, non stato del sistema → sempre NON fatale
+    log = os.path.expanduser(LOG_PATH)
+    recent = recent_permission_errors()
+    if recent is None:
+        out(True, f'errori di permesso recenti: log assente — check saltato ({log})')
+    elif recent[0] > 0:
+        out(False, f'errori di permesso recenti: {recent[0]} nelle ultime 24h '
+                   f'(ultimo: {recent[1]}) — log: {log} — warning non fatale: '
+                   'vedi i pending con `safekeep sync-once --dry-run`, poi '
+                   'riconcedere i permessi al volume (FDA/Full Disk Access)')
+    else:
+        out(True, f'errori di permesso recenti: nessuno nelle ultime 24h — log: {log}')
+
+    # WSL (SPEC.md §17.2): tre righe informative — nessuna è mai fatale
+    if is_wsl():
+        out(True, f'WSL rilevato: {wsl_distro() or "sconosciuta"} '
+                  '(supporto best-effort, SPEC §17)')
+        if not systemd_user_available():
+            out(False, 'systemd user non disponibile (WSL1 o systemd spento) — '
+                       'abilita systemd in /etc/wsl.conf: [boot] systemd=true '
+                       '(poi wsl --shutdown da Windows) oppure esegui '
+                       '`safekeep run` a mano — warning non fatale')
+        if daemon is not None:
+            sotto_mnt = [p for p in list(daemon.cfg.sources)
+                         + list(daemon.cfg.dests) if p.startswith('/mnt/')]
+            if sotto_mnt:
+                out(True, f'drvfs: {len(sotto_mnt)} path sotto /mnt/ — I/O lento '
+                          'e case-insensitive di default: valuta una dest su ext4 '
+                          'nativa della distro (SPEC §17.2)')
+
     # Linux: il limite di watch di inotify è il rischio #1 sugli alberi grandi
     # (SPEC.md §14.4) — informativo, NON fatale
     if is_linux():
@@ -296,6 +334,17 @@ def cmd_doctor(args):
                                'del template — rilancia install.sh', is_fatal=True)
                 else:
                     out(True, f'unit systemd: {unit}')
+            # linger: solo dove la unit è installata (SPEC.md §14.4) — non fatale
+            enabled = linger_enabled()
+            if enabled is None:
+                out(True, 'linger: non verificabile (/var/lib/systemd/linger '
+                          'assente) — check saltato')
+            elif enabled:
+                out(True, 'linger: abilitato (agent al boot anche senza login)')
+            else:
+                out(False, "linger: NON abilitato — l'agent non partirà al boot "
+                           'senza login → loginctl enable-linger $USER — '
+                           'warning non fatale')
 
     return 1 if fatal else 0
 

{safekeep-0.3.0 → safekeep-0.4.0}/safekeep/daemon.py

@@ -27,7 +27,7 @@ from .config import (
 )
 from .copier import MOUNT_ERRNOS, copy_one, needs_copy, prune_project, reconcile_project
 from .matcher import BUILTIN_RULES, Matcher, _glob, parse_rule
-from .platform import fswatch_monitor, init_system
+from .platform import LOG_PATH, fswatch_monitor, init_system
 from .volumes import backoff_schedule, dest_state, partition_dests
 
 log = logging.getLogger('safekeep')
@@ -271,7 +271,7 @@ def setup_logging(level='info', logfile=None):
     logger._safekeep_handlers = True
     fmt = logging.Formatter('%(asctime)s %(levelname)s %(message)s')
     if logfile is None:
-        logfile = os.path.expanduser('~/.local/state/safekeep/safekeep.log')
+        logfile = os.path.expanduser(LOG_PATH)
     try:
         os.makedirs(os.path.dirname(logfile), exist_ok=True)
         handler = logging.handlers.RotatingFileHandler(

safekeep-0.4.0/safekeep/platform.py

@@ -0,0 +1,147 @@
+"""Rilevamento piattaforma (SPEC.md §14.1): l'unico posto che legge `sys.platform`.
+
+Funzioni/constanti minime: monitor fswatch atteso, hint di installazione,
+init system, limite di watch di inotify, log corrente, linger systemd,
+rilevamento WSL. Tutto letto **a chiamata** (mai a import), così i test
+patchano `sys.platform` ed esercitano entrambi i rami anche girando su una
+sola piattaforma.
+
+I nomi dei monitor sono quelli stampati da `fswatch -M`: `fsevents_monitor`
+(FSEvents, macOS) e `inotify_monitor` (inotify, Linux) — attenzione, su Linux
+il nome NON è `inotify` (SPEC.md §14.2).
+"""
+import getpass
+import os
+import platform as _platform
+import re
+import shutil
+import sys
+from datetime import datetime
+
+INOTIFY_LIMIT_PATH = '/proc/sys/fs/inotify/max_user_watches'
+INOTIFY_MIN_WATCHES = 16384        # sotto questa soglia un home medio lo supera
+LOG_PATH = '~/.local/state/safekeep/safekeep.log'   # log corrente (SPEC.md §3)
+LINGER_DIR = '/var/lib/systemd/linger'
+SYSTEMD_RUN_PATH = '/run/systemd/system'            # assente su WSL1/systemd off
+# EPERM (Errno 1) / EACCES (Errno 13) come li scrive il logger: codice errno
+# + testo del kernel (SPEC.md §14.4)
+PERM_ERR_RE = re.compile(r'\[Errno (?:1|13)\]|Operation not permitted|Permission denied')
+
+
+def is_darwin():
+    return sys.platform == 'darwin'
+
+
+def is_linux():
+    return sys.platform == 'linux'
+
+
+def fswatch_monitor():
+    """Monitor fswatch per la piattaforma (SPEC.md §14.2), usato da
+    `daemon.fswatch_argv()` e dal check monitor di `doctor`."""
+    return 'fsevents_monitor' if is_darwin() else 'inotify_monitor'
+
+
+def init_system():
+    """`launchd` (Darwin) o `systemd` (Linux) — SPEC.md §14.3."""
+    return 'launchd' if is_darwin() else 'systemd'
+
+
+def install_hint():
+    """Come installare `fswatch` su questa macchina (SPEC.md §14.4)."""
+    if is_darwin():
+        return 'brew install fswatch'
+    for pm, cmd in (('pacman', 'pacman -S fswatch'),
+                    ('apt-get', 'sudo apt-get install fswatch'),
+                    ('dnf', 'sudo dnf install fswatch')):
+        if shutil.which(pm):
+            return cmd
+    return 'installa fswatch col package manager della tua distro'
+
+
+def inotify_limit(path=INOTIFY_LIMIT_PATH):
+    """`fs.inotify.max_user_watches`, o None se il file non c'è o è illeggibile
+    (SPEC.md §14.4: su Linux è il rischio #1 sugli alberi grandi)."""
+    try:
+        with open(path) as fh:
+            return int(fh.read().strip())
+    except (OSError, ValueError):
+        return None
+
+
+def recent_permission_errors(path=None, now=None, window=86400):
+    """`(conteggio, ultimo timestamp)` degli errori di permesso nelle ultime
+    `window` secondi del log corrente, o None se il log non c'è/non è leggibile
+    (SPEC.md §14.4: check non fatale, finestra 24h — segue l'incidente EPERM).
+
+    Il timestamp è il prefisso `%(asctime)s` della riga (`YYYY-MM-DD HH:MM:SS`,
+    prime 19 posizioni). **Limite dichiarato**: una riga senza timestamp
+    parsificabile o fuori dalla finestra (clock skew incluso) non viene contata —
+    non essendo sicuri che sia recente, non la contiamo: il conteggio è un minimo."""
+    if path is None:
+        path = os.path.expanduser(LOG_PATH)
+    if now is None:
+        now = datetime.now()
+    count, last = 0, None
+    try:
+        with open(path, encoding='utf-8', errors='replace') as fh:
+            for line in fh:
+                if not PERM_ERR_RE.search(line):
+                    continue
+                try:
+                    ts = datetime.strptime(line[:19], '%Y-%m-%d %H:%M:%S')
+                except ValueError:
+                    continue        # timestamp illeggibile → non sicuri, salta
+                age = (now - ts).total_seconds()
+                if not 0 <= age <= window:
+                    continue        # troppo vecchio (o nel futuro: clock skew)
+                count += 1
+                if last is None or ts > last:
+                    last = ts
+    except OSError:
+        return None
+    return count, last
+
+
+def linger_enabled(user=None, linger_dir=None):
+    """`True`/`False` se l'utente è in `/var/lib/systemd/linger/`, None se la
+    directory non c'è (niente systemd → non determinabile, SPEC.md §14.4).
+    Legge la directory direttamente: stessa informazione di
+    `loginctl show-user $USER -p Linger`, senza root."""
+    if linger_dir is None:
+        linger_dir = LINGER_DIR
+    try:
+        entries = os.listdir(linger_dir)
+    except OSError:
+        return None
+    if user is None:
+        try:
+            user = getpass.getuser()
+        except OSError:
+            return None
+    return user in entries
+
+
+def is_wsl():
+    """True dentro WSL (Windows Subsystem for Linux) — SPEC.md §17.1.
+
+    `sys.platform` resta `linux` su WSL: il rilevamento passa dall'env
+    `WSL_DISTRO_NAME` (ogni distro WSL lo settà) oppure dal kernel
+    (`platform.release()` contiene `microsoft` su WSL1 e WSL2)."""
+    if os.environ.get('WSL_DISTRO_NAME'):
+        return True
+    return 'microsoft' in _platform.release().lower()
+
+
+def wsl_distro():
+    """Nome della distro WSL (env `WSL_DISTRO_NAME`), vuoto se assente —
+    SPEC.md §17.1."""
+    return os.environ.get('WSL_DISTRO_NAME', '')
+
+
+def systemd_user_available(path=None):
+    """True se c'è un init systemd vivo (`/run/systemd/system`): assente su
+    WSL1 o con systemd spento in WSL2 — SPEC.md §17.2."""
+    if path is None:
+        path = SYSTEMD_RUN_PATH
+    return os.path.exists(path)

{safekeep-0.3.0 → safekeep-0.4.0/safekeep.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: safekeep
-Version: 0.3.0
+Version: 0.4.0
 Summary: Selective always-on backups for macOS and Linux: fswatch-driven copy of allow-listed files, never deletes
 License-Expression: MIT
 Project-URL: Repository, https://github.com/foxhound87/safekeep

{safekeep-0.3.0 → safekeep-0.4.0}/tests/test_cli.py

@@ -4,6 +4,7 @@ Ogni run è un subprocess con HOME finto: niente scritture nella home reale.
 """
 import argparse
 import contextlib
+import getpass
 import io
 import os
 import shutil
@@ -11,9 +12,10 @@ import subprocess
 import sys
 import tempfile
 import unittest
+from datetime import datetime, timedelta
 from unittest import mock
 
-from safekeep import cli
+from safekeep import cli, platform as plat
 from safekeep.platform import fswatch_monitor
 
 REPO = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
@@ -271,5 +273,158 @@ class PruneCliTest(CliTestCase):
             self.assertTrue(os.path.exists(os.path.join(self.dest, keep)), keep)
 
 
+class DoctorPermessiRecentiTest(CliTestCase):
+    """SPEC.md §14.4: errori di permesso nel log corrente — finestra 24h,
+    warning non fatale, log assente ⇒ check saltato."""
+
+    def log_path(self):
+        return os.path.join(self.home, '.local/state/safekeep/safekeep.log')
+
+    @staticmethod
+    def stamp(delta):
+        return (datetime.now() - delta).strftime('%Y-%m-%d %H:%M:%S,000')
+
+    def riga(self, delta, msg='[Errno 1] Operation not permitted: /x.tmp.1'):
+        return f'{self.stamp(delta)} ERROR copia fallita a → b: {msg}\n'
+
+    def riga_doctor(self, stdout):
+        self.assertIn('errori di permesso', stdout, stdout)
+        return next(l for l in stdout.splitlines() if 'errori di permesso' in l)
+
+    def test_errore_recente_warning_non_fatale(self):
+        write(self.log_path(), self.riga(timedelta(hours=3)))
+        r = self.cli('doctor', '--config', self.cfg)
+        line = self.riga_doctor(r.stdout)
+        self.assertTrue(line.startswith('✗'), line)
+        for needle in ('nelle ultime 24h', 'warning non fatale',
+                       'sync-once --dry-run', 'Full Disk Access',
+                       self.log_path()):
+            self.assertIn(needle, line, needle)
+        self.assertEqual(r.returncode, 0, r.stdout)      # NON fatale
+
+    def test_errore_vecchio_verde(self):
+        write(self.log_path(),
+              self.riga(timedelta(days=3), '[Errno 13] Permission denied'))
+        r = self.cli('doctor', '--config', self.cfg)
+        line = self.riga_doctor(r.stdout)
+        self.assertTrue(line.startswith('✔'), line)
+        self.assertIn('nessuno nelle ultime 24h', line)
+
+    def test_log_assente_check_saltato(self):
+        r = self.cli('doctor', '--config', self.cfg)     # nessun log nel HOME finto
+        line = self.riga_doctor(r.stdout)
+        self.assertTrue(line.startswith('✔'), line)
+        self.assertIn('check saltato', line)
+
+
+@unittest.skipUnless(shutil.which('fswatch'), 'fswatch non installato')
+class DoctorLingerTest(CliTestCase):
+    """SPEC.md §14.4: linger solo dove c'è la unit systemd, warning non fatale."""
+
+    def doctor_linux(self, unit=True, linger=()):
+        if unit:
+            write(os.path.join(self.home, '.config/systemd/user/safekeep.service'),
+                  '[Unit]\nDescription=safekeep\n')
+        linger_dir = tempfile.mkdtemp()
+        self.addCleanup(shutil.rmtree, linger_dir, ignore_errors=True)
+        for name in linger:
+            open(os.path.join(linger_dir, name), 'w').close()
+        args = argparse.Namespace(config=self.cfg, v=False)
+        buf = io.StringIO()
+        with mock.patch.dict(os.environ, {'HOME': self.home}), \
+                mock.patch.object(cli, 'is_linux', return_value=True), \
+                mock.patch.object(cli, 'is_darwin', return_value=False), \
+                mock.patch.object(plat, 'LINGER_DIR', linger_dir), \
+                contextlib.redirect_stdout(buf):
+            code = cli.cmd_doctor(args)
+        return code, buf.getvalue()
+
+    @staticmethod
+    def riga_linger(out):
+        return next(l for l in out.splitlines() if 'linger' in l)
+
+    def test_unit_assenta_niente_linger(self):
+        code, out = self.doctor_linux(unit=False)
+        self.assertNotIn('linger', out, 'il check esiste solo con la unit installata')
+        self.assertEqual(code, 0, out)
+
+    def test_linger_disabilitato_warning_non_fatale(self):
+        code, out = self.doctor_linux(unit=True)
+        line = self.riga_linger(out)
+        self.assertTrue(line.startswith('✗'), line)
+        self.assertIn('loginctl enable-linger', line)
+        self.assertIn('warning non fatale', line)
+        self.assertEqual(code, 0, out)                   # NON fatale
+
+    def test_linger_abilitato_verde(self):
+        code, out = self.doctor_linux(unit=True, linger=(getpass.getuser(),))
+        line = self.riga_linger(out)
+        self.assertTrue(line.startswith('✔'), line)
+        self.assertEqual(code, 0, out)
+
+
+class DoctorWslTest(CliTestCase):
+    """SPEC.md §17.2: le tre righe WSL di `doctor` sono informative e non fatali."""
+
+    def doctor_wsl(self, distro='Ubuntu', systemd=False, dest='/mnt/c/backup'):
+        cfg = write(os.path.join(self.tmp, 'wsl.cfg'), f'dest: {dest}\n')
+        args = argparse.Namespace(config=cfg, v=False)
+        buf = io.StringIO()
+        with mock.patch.dict(os.environ, {'HOME': self.home}), \
+                mock.patch.object(cli, 'is_wsl', return_value=True), \
+                mock.patch.object(cli, 'wsl_distro', return_value=distro), \
+                mock.patch.object(cli, 'systemd_user_available',
+                                  return_value=systemd), \
+                contextlib.redirect_stdout(buf):
+            code = cli.cmd_doctor(args)
+        return code, buf.getvalue()
+
+    @unittest.skipUnless(shutil.which('fswatch'), 'fswatch non installato')
+    def test_wsle_righe_con_hint_systemd_e_drvfs(self):
+        code, out = self.doctor_wsl()
+        self.assertIn('✔ WSL rilevato: Ubuntu', out)
+        hint = next(l for l in out.splitlines()
+                    if 'systemd user non disponibile' in l)
+        self.assertTrue(hint.startswith('✗'), hint)
+        for needle in ('/etc/wsl.conf', 'systemd=true', 'safekeep run',
+                       'warning non fatale'):
+            self.assertIn(needle, hint, needle)
+        drvfs = next(l for l in out.splitlines() if 'drvfs' in l)
+        self.assertIn('/mnt/', drvfs)
+        self.assertEqual(code, 0, out)                     # mai fatale
+
+    @unittest.skipUnless(shutil.which('fswatch'), 'fswatch non installato')
+    def test_systemd_attivo_nessun_hint(self):
+        code, out = self.doctor_wsl(systemd=True)
+        self.assertNotIn('systemd user non disponibile', out)
+        self.assertIn('WSL rilevato', out)
+        self.assertEqual(code, 0, out)
+
+    @unittest.skipUnless(shutil.which('fswatch'), 'fswatch non installato')
+    def test_nessun_path_sotto_mnt_niente_drvfs(self):
+        code, out = self.doctor_wsl(dest=os.path.join(self.tmp, 'dst'))
+        self.assertNotIn('drvfs', out)
+        self.assertEqual(code, 0, out)
+
+    def test_detection_reale_via_env_fino_a_doctor(self):
+        """Detection reale (env) fino all'output di doctor: niente patch."""
+        env = dict(os.environ, HOME=self.home, WSL_DISTRO_NAME='Debian')
+        r = subprocess.run([sys.executable, CLI, 'doctor', '--config', self.cfg],
+                           capture_output=True, text=True, env=env, cwd=REPO,
+                           timeout=60)
+        self.assertIn('WSL rilevato: Debian', r.stdout)
+
+    @unittest.skipUnless(shutil.which('fswatch'), 'fswatch non installato')
+    def test_senza_wsl_nulla_cambia(self):
+        """Su Linux/macOS non-WSL nessuna riga WSL compare (SPEC §17)."""
+        env = {k: v for k, v in os.environ.items() if k != 'WSL_DISTRO_NAME'}
+        env['HOME'] = self.home
+        r = subprocess.run([sys.executable, CLI, 'doctor', '--config', self.cfg],
+                           capture_output=True, text=True, env=env, cwd=REPO,
+                           timeout=60)
+        self.assertNotIn('WSL', r.stdout)
+        self.assertNotIn('drvfs', r.stdout)
+
+
 if __name__ == '__main__':
     unittest.main()

safekeep-0.4.0/tests/test_platform.py

@@ -0,0 +1,296 @@
+"""Helper di piattaforma e agent systemd (SPEC.md §14).
+
+Entrambi i rami (Darwin/Linux) si esercitano patchando `sys.platform`, così la
+suite copre il design di portabilità anche girando su una sola piattaforma.
+"""
+import os
+import shutil
+import subprocess
+import tempfile
+import unittest
+from datetime import datetime, timedelta
+from unittest import mock
+
+from safekeep import platform as plat
+
+REPO = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+
+
+class MonitorTest(unittest.TestCase):
+    def test_monitor_dichiarato_per_piattaforma(self):
+        with mock.patch('sys.platform', 'darwin'):
+            self.assertEqual(plat.fswatch_monitor(), 'fsevents_monitor')
+        with mock.patch('sys.platform', 'linux'):
+            self.assertEqual(plat.fswatch_monitor(), 'inotify_monitor')
+
+    def test_monitor_atteso_e_in_fswatch_M(self):
+        """Guardrail contro il nome sbagliato: `-m inotify` (senza `_monitor`)
+        non è un alias accettato da fswatch — qui si verifica che il nome che
+        passiamo in `-m` sia proprio uno di quelli che `fswatch -M` elenca."""
+        exe = shutil.which('fswatch')
+        if exe is None:
+            self.skipTest('fswatch non installato')
+        out = subprocess.run([exe, '-M'], capture_output=True, text=True,
+                             timeout=15).stdout
+        self.assertIn(plat.fswatch_monitor(), out)
+
+
+class InitSystemTest(unittest.TestCase):
+    def test_init_system_per_piattaforma(self):
+        with mock.patch('sys.platform', 'darwin'):
+            self.assertEqual(plat.init_system(), 'launchd')
+        with mock.patch('sys.platform', 'linux'):
+            self.assertEqual(plat.init_system(), 'systemd')
+
+    def test_is_darwin_e_is_linux(self):
+        with mock.patch('sys.platform', 'darwin'):
+            self.assertTrue(plat.is_darwin())
+            self.assertFalse(plat.is_linux())
+        with mock.patch('sys.platform', 'linux'):
+            self.assertTrue(plat.is_linux())
+            self.assertFalse(plat.is_darwin())
+
+
+class InstallHintTest(unittest.TestCase):
+    def test_darwin_usa_brew(self):
+        with mock.patch('sys.platform', 'darwin'):
+            self.assertEqual(plat.install_hint(), 'brew install fswatch')
+
+    def test_linux_rileva_il_package_manager(self):
+        casi = (('pacman', 'pacman -S fswatch'),
+                ('apt-get', 'sudo apt-get install fswatch'),
+                ('dnf', 'sudo dnf install fswatch'))
+        for pm, atteso in casi:
+            with self.subTest(pm=pm), \
+                    mock.patch('sys.platform', 'linux'), \
+                    mock.patch('shutil.which',
+                               side_effect=lambda name, pm=pm:
+                               '/usr/bin/' + name if name == pm else None):
+                self.assertEqual(plat.install_hint(), atteso)
+
+    def test_linux_senza_package_manager_noto(self):
+        with mock.patch('sys.platform', 'linux'), \
+                mock.patch('shutil.which', return_value=None):
+            self.assertIn('fswatch', plat.install_hint())
+
+
+class InotifyLimitTest(unittest.TestCase):
+    """SPEC.md §14.4: check informativo non fatale sul limite di watch."""
+
+    def _fake(self, text):
+        fd, path = tempfile.mkstemp()
+        self.addCleanup(os.unlink, path)
+        with os.fdopen(fd, 'w') as fh:
+            fh.write(text)
+        return path
+
+    def test_lettura_da_file_finto(self):
+        self.assertEqual(plat.inotify_limit(self._fake('524288\n')), 524288)
+        self.assertEqual(plat.inotify_limit(self._fake('8192')), 8192)
+
+    def test_valore_invalido_o_file_mancante(self):
+        self.assertIsNone(plat.inotify_limit(self._fake('non-è-un-numbero\n')))
+        self.assertIsNone(plat.inotify_limit('/proc/assente/inotify'))
+
+    def test_costanti(self):
+        self.assertEqual(plat.INOTIFY_MIN_WATCHES, 16384)
+        self.assertEqual(plat.INOTIFY_LIMIT_PATH,
+                         '/proc/sys/fs/inotify/max_user_watches')
+
+
+class PiattaformaCentralizzataTest(unittest.TestCase):
+    def test_sys_platform_letto_solo_nell_helper(self):
+        """SPEC.md §14.1: un solo posto legge `sys.platform`, niente check sparsi."""
+        hits = []
+        pkg = os.path.join(REPO, 'safekeep')
+        for name in sorted(os.listdir(pkg)):
+            if not name.endswith('.py'):
+                continue
+            with open(os.path.join(pkg, name), encoding='utf-8') as fh:
+                for i, line in enumerate(fh, 1):
+                    if 'sys.platform' in line:
+                        hits.append(f'{name}:{i}')
+        self.assertTrue(hits, 'nessun riferimento a sys.platform trovato')
+        self.assertTrue(all(h.startswith('platform.py:') for h in hits), hits)
+
+
+class AgentTemplateTest(unittest.TestCase):
+    """SPEC.md §14.3: la unit systemd è un template con gli stessi placeholder
+    del plist e copre RunAtLoad/KeepAlive."""
+
+    def test_unit_systemd_template(self):
+        path = os.path.join(REPO, 'systemd', 'safekeep.service')
+        with open(path, encoding='utf-8') as fh:
+            text = fh.read()
+        for needle in ('ExecStart=__PYTHON__ __REPO__/bin/safekeep.py run',
+                       'Restart=always',
+                       'RestartSec=2',
+                       'StartLimitIntervalSec=0',
+                       'WantedBy=default.target'):
+            self.assertIn(needle, text, needle)
+        self.assertNotIn('/Users/', text, 'path assoluto nel template')
+
+    def test_gli_script_si_ramificano_per_os(self):
+        for name in ('install.sh', 'uninstall.sh'):
+            with self.subTest(script=name), \
+                    open(os.path.join(REPO, name), encoding='utf-8') as fh:
+                text = fh.read()
+            self.assertIn('uname -s', text, name)          # ramo Darwin/Linux
+            self.assertIn('launchctl', text, name)         # ramo macOS invariato
+            self.assertIn('systemctl --user', text, name)  # ramo Linux
+
+    def test_il_plist_macos_non_e_toccato(self):
+        with open(os.path.join(REPO, 'launchd', 'com.safekeep.agent.plist'),
+                  encoding='utf-8') as fh:
+            text = fh.read()
+        for needle in ('RunAtLoad', 'KeepAlive', '__REPO__', '__PYTHON__'):
+            self.assertIn(needle, text, needle)
+
+
+class RecentPermissionErrorsTest(unittest.TestCase):
+    """SPEC.md §14.4: errori di permesso recenti nel log, finestra 24h,
+    non fatale; righe senza timestamp sicuro non vengono contate."""
+
+    NOW = datetime(2026, 10, 4, 20, 0, 0)
+
+    def _log(self, text):
+        fd, path = tempfile.mkstemp(suffix='.log')
+        self.addCleanup(os.unlink, path)
+        with os.fdopen(fd, 'w') as fh:
+            fh.write(text)
+        return path
+
+    @staticmethod
+    def _stamp(dt):
+        return dt.strftime('%Y-%m-%d %H:%M:%S,000')   # formato %(asctime)s
+
+    def test_ricente_vecchio_e_normale_nello_stesso_log(self):
+        text = (
+            f'{self._stamp(self.NOW - timedelta(hours=2))} ERROR copia fallita '
+            "a → b: [Errno 1] Operation not permitted: '/x.tmp.1'\n"
+            f'{self._stamp(self.NOW - timedelta(days=3))} ERROR copia fallita '
+            "a → b: [Errno 13] Permission denied: '/y'\n"
+            f'{self._stamp(self.NOW - timedelta(minutes=5))} INFO reconcile: 0 copie\n'
+        )
+        count, last = plat.recent_permission_errors(self._log(text), now=self.NOW)
+        self.assertEqual(count, 1, 'solo la riga nelle ultime 24h')
+        self.assertEqual(last, self.NOW - timedelta(hours=2))
+
+    def test_log_assente(self):
+        self.assertIsNone(
+            plat.recent_permission_errors('/non/esiste/safekeep.log'),
+            'nessun log ⇒ check saltato, non warning')
+
+    def test_timestamp_illeggibile_non_e_contato(self):
+        text = ("senza-data ERROR [Errno 1] Operation not permitted: '/x'\n"
+                + f'{self._stamp(self.NOW - timedelta(hours=1))} ERROR '
+                  "[Errno 1] Operation not permitted: '/y'\n"
+                + f'{self._stamp(self.NOW + timedelta(hours=1))} ERROR '
+                  "[Errno 1] Operation not permitted: '/z'\n")
+        count, _ = plat.recent_permission_errors(self._log(text), now=self.NOW)
+        self.assertEqual(count, 1, 'non sicuri (o clock skew) ⇒ non contiamo')
+
+    def test_copre_eperm_e_eacces(self):
+        for riga in ('[Errno 1] Operation not permitted',
+                     'qualcosa Operation not permitted',
+                     '[Errno 13] Permission denied',
+                     'qualcosa Permission denied'):
+            with self.subTest(riga=riga):
+                self.assertIsNotNone(plat.PERM_ERR_RE.search(riga))
+        self.assertIsNone(plat.PERM_ERR_RE.search('INFO reconcile: 0 copie'))
+
+
+class LingerTest(unittest.TestCase):
+    """SPEC.md §14.4: linger systemd, directory finta al posto di
+    /var/lib/systemd/linger."""
+
+    def _dir(self, *entries):
+        path = tempfile.mkdtemp()
+        self.addCleanup(shutil.rmtree, path, ignore_errors=True)
+        for name in entries:
+            open(os.path.join(path, name), 'w').close()
+        return path
+
+    def test_abilitato_disabilitato_e_dir_assente(self):
+        d = self._dir('utente')
+        self.assertTrue(plat.linger_enabled(user='utente', linger_dir=d))
+        self.assertFalse(plat.linger_enabled(user='altro', linger_dir=d))
+        self.assertIsNone(
+            plat.linger_enabled(user='utente',
+                                linger_dir=os.path.join(os.sep, 'niente', 'qui')),
+            'niente systemd ⇒ non determinabile, check saltato')
+
+    def test_user_default_e_costante(self):
+        self.assertEqual(plat.LINGER_DIR, '/var/lib/systemd/linger')
+        with mock.patch('getpass.getuser', return_value='chi'):
+            self.assertTrue(plat.linger_enabled(linger_dir=self._dir('chi')))
+            self.assertFalse(plat.linger_enabled(linger_dir=self._dir()))
+
+
+class WslTest(unittest.TestCase):
+    """SPEC.md §17.1: rilevamento WSL via env o kernel, letto a chiamata."""
+
+    def test_env_wsl_distro_name(self):
+        with mock.patch.dict(os.environ, {'WSL_DISTRO_NAME': 'Ubuntu'}):
+            self.assertTrue(plat.is_wsl())
+            self.assertEqual(plat.wsl_distro(), 'Ubuntu')
+
+    def test_kernel_microsoft_senza_env(self):
+        for release in ('5.15.167.4-microsoft-standard-WSL2',   # WSL2
+                        '4.4.0-19041-Microsoft'):              # WSL1 (maiuscolo)
+            with self.subTest(release=release), \
+                    mock.patch.dict(os.environ, {'WSL_DISTRO_NAME': ''}), \
+                    mock.patch.object(plat, '_platform') as p:
+                p.release.return_value = release
+                self.assertTrue(plat.is_wsl())
+                self.assertEqual(plat.wsl_distro(), '')
+
+    def test_non_wsl(self):
+        with mock.patch.dict(os.environ, {'WSL_DISTRO_NAME': ''}), \
+                mock.patch.object(plat, '_platform') as p:
+            p.release.return_value = '24.6.0'             # macOS, niente microsoft
+            self.assertFalse(plat.is_wsl())
+            self.assertEqual(plat.wsl_distro(), '')
+
+    def test_systemd_user_available(self):
+        with tempfile.TemporaryDirectory() as d:
+            self.assertTrue(plat.systemd_user_available(path=d))
+        self.assertFalse(
+            plat.systemd_user_available(path='/non/esiste/qui'),
+            '/run/systemd/system assente = WSL1 o systemd spento (SPEC §17.2)')
+
+
+@unittest.skipUnless(shutil.which('fswatch'), 'fswatch non installato')
+class InstallShSenzaSystemdTest(unittest.TestCase):
+    """SPEC.md §17.3: `install.sh` su Linux senza systemd → unit NON installata,
+    istruzioni di avvio manuale ed exit 0 (nessun errore duro)."""
+
+    def test_ramo_linux_senza_systemd_esce_0(self):
+        if os.path.isdir('/run/systemd/system'):
+            self.skipTest('questa macchina ha systemd: ramo diverso')
+        tmp = tempfile.mkdtemp()
+        self.addCleanup(shutil.rmtree, tmp, ignore_errors=True)
+        home, fake_bin = os.path.join(tmp, 'home'), os.path.join(tmp, 'bin')
+        os.makedirs(home)
+        os.makedirs(fake_bin)
+        uname = os.path.join(fake_bin, 'uname')            # uname finto → Linux
+        with open(uname, 'w') as fh:
+            fh.write('#!/bin/bash\necho Linux\n')
+        os.chmod(uname, 0o755)
+        env = dict(os.environ, HOME=home,
+                   PATH=fake_bin + os.pathsep + os.environ['PATH'])
+        r = subprocess.run(['bash', os.path.join(REPO, 'install.sh')],
+                           capture_output=True, text=True, env=env, timeout=60)
+        self.assertEqual(r.returncode, 0, r.stdout + r.stderr)
+        self.assertIn('systemd non disponibile', r.stdout)
+        self.assertIn('safekeep.py run', r.stdout)         # avvio manuale
+        self.assertIn('systemd=true', r.stdout)            # hint /etc/wsl.conf
+        self.assertTrue(os.path.exists(os.path.join(home, '.safekeep')),
+                        'la config viene creata comunque')
+        self.assertFalse(os.path.exists(
+            os.path.join(home, '.config/systemd/user/safekeep.service')),
+            'niente unit senza systemd')
+
+
+if __name__ == '__main__':
+    unittest.main()

safekeep-0.3.0/safekeep/platform.py

@@ -1,57 +0,0 @@
-"""Rilevamento piattaforma (SPEC.md §14.1): l'unico posto che legge `sys.platform`.
-
-Funzioni/constanti minime: monitor fswatch atteso, hint di installazione,
-init system, limite di watch di inotify. Tutto letto **a chiamata** (mai a
-import), così i test patchano `sys.platform` ed esercitano entrambi i rami
-anche girando su una sola piattaforma.
-
-I nomi dei monitor sono quelli stampati da `fswatch -M`: `fsevents_monitor`
-(FSEvents, macOS) e `inotify_monitor` (inotify, Linux) — attenzione, su Linux
-il nome NON è `inotify` (SPEC.md §14.2).
-"""
-import shutil
-import sys
-
-INOTIFY_LIMIT_PATH = '/proc/sys/fs/inotify/max_user_watches'
-INOTIFY_MIN_WATCHES = 16384        # sotto questa soglia un home medio lo supera
-
-
-def is_darwin():
-    return sys.platform == 'darwin'
-
-
-def is_linux():
-    return sys.platform == 'linux'
-
-
-def fswatch_monitor():
-    """Monitor fswatch per la piattaforma (SPEC.md §14.2), usato da
-    `daemon.fswatch_argv()` e dal check monitor di `doctor`."""
-    return 'fsevents_monitor' if is_darwin() else 'inotify_monitor'
-
-
-def init_system():
-    """`launchd` (Darwin) o `systemd` (Linux) — SPEC.md §14.3."""
-    return 'launchd' if is_darwin() else 'systemd'
-
-
-def install_hint():
-    """Come installare `fswatch` su questa macchina (SPEC.md §14.4)."""
-    if is_darwin():
-        return 'brew install fswatch'
-    for pm, cmd in (('pacman', 'pacman -S fswatch'),
-                    ('apt-get', 'sudo apt-get install fswatch'),
-                    ('dnf', 'sudo dnf install fswatch')):
-        if shutil.which(pm):
-            return cmd
-    return 'installa fswatch col package manager della tua distro'
-
-
-def inotify_limit(path=INOTIFY_LIMIT_PATH):
-    """`fs.inotify.max_user_watches`, o None se il file non c'è o è illeggibile
-    (SPEC.md §14.4: su Linux è il rischio #1 sugli alberi grandi)."""
-    try:
-        with open(path) as fh:
-            return int(fh.read().strip())
-    except (OSError, ValueError):
-        return None

safekeep-0.3.0/tests/test_platform.py

@@ -1,150 +0,0 @@
-"""Helper di piattaforma e agent systemd (SPEC.md §14).
-
-Entrambi i rami (Darwin/Linux) si esercitano patchando `sys.platform`, così la
-suite copre il design di portabilità anche girando su una sola piattaforma.
-"""
-import os
-import shutil
-import subprocess
-import tempfile
-import unittest
-from unittest import mock
-
-from safekeep import platform as plat
-
-REPO = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
-
-
-class MonitorTest(unittest.TestCase):
-    def test_monitor_dichiarato_per_piattaforma(self):
-        with mock.patch('sys.platform', 'darwin'):
-            self.assertEqual(plat.fswatch_monitor(), 'fsevents_monitor')
-        with mock.patch('sys.platform', 'linux'):
-            self.assertEqual(plat.fswatch_monitor(), 'inotify_monitor')
-
-    def test_monitor_atteso_e_in_fswatch_M(self):
-        """Guardrail contro il nome sbagliato: `-m inotify` (senza `_monitor`)
-        non è un alias accettato da fswatch — qui si verifica che il nome che
-        passiamo in `-m` sia proprio uno di quelli che `fswatch -M` elenca."""
-        exe = shutil.which('fswatch')
-        if exe is None:
-            self.skipTest('fswatch non installato')
-        out = subprocess.run([exe, '-M'], capture_output=True, text=True,
-                             timeout=15).stdout
-        self.assertIn(plat.fswatch_monitor(), out)
-
-
-class InitSystemTest(unittest.TestCase):
-    def test_init_system_per_piattaforma(self):
-        with mock.patch('sys.platform', 'darwin'):
-            self.assertEqual(plat.init_system(), 'launchd')
-        with mock.patch('sys.platform', 'linux'):
-            self.assertEqual(plat.init_system(), 'systemd')
-
-    def test_is_darwin_e_is_linux(self):
-        with mock.patch('sys.platform', 'darwin'):
-            self.assertTrue(plat.is_darwin())
-            self.assertFalse(plat.is_linux())
-        with mock.patch('sys.platform', 'linux'):
-            self.assertTrue(plat.is_linux())
-            self.assertFalse(plat.is_darwin())
-
-
-class InstallHintTest(unittest.TestCase):
-    def test_darwin_usa_brew(self):
-        with mock.patch('sys.platform', 'darwin'):
-            self.assertEqual(plat.install_hint(), 'brew install fswatch')
-
-    def test_linux_rileva_il_package_manager(self):
-        casi = (('pacman', 'pacman -S fswatch'),
-                ('apt-get', 'sudo apt-get install fswatch'),
-                ('dnf', 'sudo dnf install fswatch'))
-        for pm, atteso in casi:
-            with self.subTest(pm=pm), \
-                    mock.patch('sys.platform', 'linux'), \
-                    mock.patch('shutil.which',
-                               side_effect=lambda name, pm=pm:
-                               '/usr/bin/' + name if name == pm else None):
-                self.assertEqual(plat.install_hint(), atteso)
-
-    def test_linux_senza_package_manager_noto(self):
-        with mock.patch('sys.platform', 'linux'), \
-                mock.patch('shutil.which', return_value=None):
-            self.assertIn('fswatch', plat.install_hint())
-
-
-class InotifyLimitTest(unittest.TestCase):
-    """SPEC.md §14.4: check informativo non fatale sul limite di watch."""
-
-    def _fake(self, text):
-        fd, path = tempfile.mkstemp()
-        self.addCleanup(os.unlink, path)
-        with os.fdopen(fd, 'w') as fh:
-            fh.write(text)
-        return path
-
-    def test_lettura_da_file_finto(self):
-        self.assertEqual(plat.inotify_limit(self._fake('524288\n')), 524288)
-        self.assertEqual(plat.inotify_limit(self._fake('8192')), 8192)
-
-    def test_valore_invalido_o_file_mancante(self):
-        self.assertIsNone(plat.inotify_limit(self._fake('non-è-un-numbero\n')))
-        self.assertIsNone(plat.inotify_limit('/proc/assente/inotify'))
-
-    def test_costanti(self):
-        self.assertEqual(plat.INOTIFY_MIN_WATCHES, 16384)
-        self.assertEqual(plat.INOTIFY_LIMIT_PATH,
-                         '/proc/sys/fs/inotify/max_user_watches')
-
-
-class PiattaformaCentralizzataTest(unittest.TestCase):
-    def test_sys_platform_letto_solo_nell_helper(self):
-        """SPEC.md §14.1: un solo posto legge `sys.platform`, niente check sparsi."""
-        hits = []
-        pkg = os.path.join(REPO, 'safekeep')
-        for name in sorted(os.listdir(pkg)):
-            if not name.endswith('.py'):
-                continue
-            with open(os.path.join(pkg, name), encoding='utf-8') as fh:
-                for i, line in enumerate(fh, 1):
-                    if 'sys.platform' in line:
-                        hits.append(f'{name}:{i}')
-        self.assertTrue(hits, 'nessun riferimento a sys.platform trovato')
-        self.assertTrue(all(h.startswith('platform.py:') for h in hits), hits)
-
-
-class AgentTemplateTest(unittest.TestCase):
-    """SPEC.md §14.3: la unit systemd è un template con gli stessi placeholder
-    del plist e copre RunAtLoad/KeepAlive."""
-
-    def test_unit_systemd_template(self):
-        path = os.path.join(REPO, 'systemd', 'safekeep.service')
-        with open(path, encoding='utf-8') as fh:
-            text = fh.read()
-        for needle in ('ExecStart=__PYTHON__ __REPO__/bin/safekeep.py run',
-                       'Restart=always',
-                       'RestartSec=2',
-                       'StartLimitIntervalSec=0',
-                       'WantedBy=default.target'):
-            self.assertIn(needle, text, needle)
-        self.assertNotIn('/Users/', text, 'path assoluto nel template')
-
-    def test_gli_script_si_ramificano_per_os(self):
-        for name in ('install.sh', 'uninstall.sh'):
-            with self.subTest(script=name), \
-                    open(os.path.join(REPO, name), encoding='utf-8') as fh:
-                text = fh.read()
-            self.assertIn('uname -s', text, name)          # ramo Darwin/Linux
-            self.assertIn('launchctl', text, name)         # ramo macOS invariato
-            self.assertIn('systemctl --user', text, name)  # ramo Linux
-
-    def test_il_plist_macos_non_e_toccato(self):
-        with open(os.path.join(REPO, 'launchd', 'com.safekeep.agent.plist'),
-                  encoding='utf-8') as fh:
-            text = fh.read()
-        for needle in ('RunAtLoad', 'KeepAlive', '__REPO__', '__PYTHON__'):
-            self.assertIn(needle, text, needle)
-
-
-if __name__ == '__main__':
-    unittest.main()