safekeep 0.2.0__tar.gz → 0.3.0__tar.gz

{safekeep-0.2.0 → safekeep-0.3.0}/PKG-INFO

@@ -1,16 +1,22 @@
 Metadata-Version: 2.4
 Name: safekeep
-Version: 0.2.0
-Summary: Selective always-on backups for macOS: fswatch-driven copy of allow-listed files, never deletes
+Version: 0.3.0
+Summary: Selective always-on backups for macOS and Linux: fswatch-driven copy of allow-listed files, never deletes
 License-Expression: MIT
-Project-URL: Homepage, https://gitlab.com/foxhound87/safekeep
-Project-URL: Repository, https://gitlab.com/foxhound87/safekeep
-Keywords: backup,macos,fswatch,sync,allow-list,launchd
+Project-URL: Repository, https://github.com/foxhound87/safekeep
+Project-URL: Homepage, https://foxhound87.github.io/safekeep/
+Project-URL: Documentation, https://foxhound87.github.io/safekeep/
+Keywords: backup,macos,linux,fswatch,sync,allow-list,launchd,systemd
 Classifier: Development Status :: 4 - Beta
 Classifier: Environment :: Console
 Classifier: Intended Audience :: System Administrators
 Classifier: Operating System :: MacOS
+Classifier: Operating System :: POSIX
+Classifier: Operating System :: POSIX :: Linux
 Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: System :: Archiving :: Backup
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
@@ -19,12 +25,17 @@ Dynamic: license-file
 
 # safekeep
 
-**Selective always-on backups for macOS**: watches source folders with
+[![PyPI](https://img.shields.io/pypi/v/safekeep)](https://pypi.org/project/safekeep/)
+[![Python](https://img.shields.io/pypi/pyversions/safekeep)](https://pypi.org/project/safekeep/)
+
+**Selective always-on backups for macOS and Linux**: watches source folders with
 [fswatch](https://github.com/emcrisostomo/fswatch) and copies only the files you
 chose to their destinations — an **allow-list** model that **never deletes**
 anything in the backup (a file removed or renamed at the source stays in the
 backup).
 
+Documentation: https://foxhound87.github.io/safekeep/
+
 ## Features
 
 - **Allow-list**: a file is copied only if it matches at least one `include:`;
@@ -38,7 +49,8 @@ backup).
   don't matter, the next reconcile brings everything back in sync.
 - **Unmounted volumes**: missing destination → `pending` state with exponential
   backoff (1s → 60s cap), then a reconcile once the mount is back.
-- **launchd at boot**: an agent with `RunAtLoad` + `KeepAlive` keeps the process
+- **launchd (macOS) or systemd (Linux) at boot**: an agent with `RunAtLoad` +
+  `KeepAlive` (or `WantedBy=default.target` + `Restart=always`) keeps the process
   alive and restarts it if it dies.
 - **`.sync` carries rules only, destinations live only in `~/.safekeep`**: a
   `.sync` file can neither add nor remove destinations (a `dest:` line is an
@@ -53,27 +65,31 @@ pipx install safekeep     # recommended for a CLI
 pip install safekeep
 ```
 
-**Requirements**: macOS, Python >= 3.9 and
+**Requirements**: macOS or Linux (POSIX with systemd), Python >= 3.9 and
 [fswatch](https://github.com/emcrisostomo/fswatch):
 
 ```bash
-brew install fswatch
+brew install fswatch      # macOS
+sudo pacman -S fswatch    # Arch / Omarchy
+sudo apt install fswatch  # Debian / Ubuntu
+sudo dnf install fswatch  # Fedora
 ```
 
-The **launchd agent** (daemon at boot) is installed from a checkout of this
-repository with `./install.sh` — not from the wheel — see
-[Agent (launchd)](#agent-launchd) below.
+The **agent** (daemon at boot: launchd on macOS, a systemd *user unit* on Linux)
+is installed from a checkout of this repository with `./install.sh` — not from
+the wheel — see [Agent](#agent) below.
 
-## Agent (launchd)
+## Agent
 
 ```bash
-git clone https://gitlab.com/foxhound87/safekeep.git
+git clone https://github.com/foxhound87/safekeep.git
 cd safekeep
 
-# only external dependency, if not installed yet
-brew install fswatch
+# only external dependency, if not installed yet (see the per-OS list above)
+brew install fswatch      # macOS — the script suggests the right command on Linux
 
-# copies the example into ~/.safekeep, renders the plist, runs preflight checks
+# copies the example into ~/.safekeep, renders the plist / systemd unit,
+# runs preflight checks
 bash install.sh
 ```
 
@@ -88,12 +104,21 @@ Then:
 3. load the agent:
 
 ```bash
+# macOS (launchd)
 launchctl bootstrap gui/$(id -u) ~/Library/LaunchAgents/com.safekeep.agent.plist
 # unload with: launchctl bootout gui/$(id -u)/com.safekeep.agent
+
+# Linux (systemd user unit)
+systemctl --user enable --now safekeep
+# status with: systemctl --user status safekeep
+# logs with:   journalctl --user -u safekeep -f
+# unload with: systemctl --user disable --now safekeep
+# start at boot without a login session: loginctl enable-linger $USER
 ```
 
-Once you have granted TCC/FDA (Full Disk Access) permissions to the Python
-interpreter and to `fswatch`, run `safekeep doctor` for diagnostics.
+On macOS, once you have granted TCC/FDA (Full Disk Access) permissions to the
+Python interpreter and to `fswatch`, run `safekeep doctor` for diagnostics. On
+Linux the same command checks the `inotify` watch limit instead.
 
 ## Quickstart
 
@@ -157,7 +182,7 @@ safekeep <command> [--config PATH] [-v]
 | `run` | daemon: initial reconcile, fswatch loop, event dispatch, 24h timer |
 | `sync-once [--dry-run] [--project PATH] [--prune]` | a single pass: walks the source and copies whatever differs (`--dry-run` only prints what it would copy; `--prune` also removes dest files whose source still exists but is no longer included) |
 | `status` | read-only: config, sources, discovered projects with N rules, destination states |
-| `doctor` | diagnostics: config, fswatch, TCC, launchd plist — exits non-zero if a fatal check fails |
+| `doctor` | diagnostics: config, fswatch + platform monitor, python, TCC/launchd plist (macOS), inotify limit and systemd unit (Linux) — exits non-zero if a fatal check fails |
 
 ## Tests
 
@@ -165,9 +190,12 @@ safekeep <command> [--config PATH] [-v]
 python3 -m unittest discover -s tests
 ```
 
-Stdlib (`unittest`) suite, zero dependencies: 156 tests covering the matcher,
-config, atomic copy, volumes, daemon, auto-discovery and CLI. `fswatch` is not
-needed to run the tests.
+Stdlib (`unittest`) suite, zero dependencies: 175 tests covering the matcher,
+config, atomic copy, volumes, daemon, auto-discovery, CLI and the POSIX
+portability layer (platform helper, per-OS fswatch monitor, systemd template).
+`fswatch` is not needed to run the suite — the few `doctor` checks that talk to
+the real binary are skipped when it's missing — but CI installs it so the
+Linux job exercises the real `inotify` monitor.
 
 ## Documentation
 

safekeep-0.2.0/safekeep.egg-info/PKG-INFO → safekeep-0.3.0/README.md

@@ -1,30 +1,16 @@
-Metadata-Version: 2.4
-Name: safekeep
-Version: 0.2.0
-Summary: Selective always-on backups for macOS: fswatch-driven copy of allow-listed files, never deletes
-License-Expression: MIT
-Project-URL: Homepage, https://gitlab.com/foxhound87/safekeep
-Project-URL: Repository, https://gitlab.com/foxhound87/safekeep
-Keywords: backup,macos,fswatch,sync,allow-list,launchd
-Classifier: Development Status :: 4 - Beta
-Classifier: Environment :: Console
-Classifier: Intended Audience :: System Administrators
-Classifier: Operating System :: MacOS
-Classifier: Programming Language :: Python :: 3
-Classifier: Topic :: System :: Archiving :: Backup
-Requires-Python: >=3.9
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Dynamic: license-file
-
 # safekeep
 
-**Selective always-on backups for macOS**: watches source folders with
+[![PyPI](https://img.shields.io/pypi/v/safekeep)](https://pypi.org/project/safekeep/)
+[![Python](https://img.shields.io/pypi/pyversions/safekeep)](https://pypi.org/project/safekeep/)
+
+**Selective always-on backups for macOS and Linux**: watches source folders with
 [fswatch](https://github.com/emcrisostomo/fswatch) and copies only the files you
 chose to their destinations — an **allow-list** model that **never deletes**
 anything in the backup (a file removed or renamed at the source stays in the
 backup).
 
+Documentation: https://foxhound87.github.io/safekeep/
+
 ## Features
 
 - **Allow-list**: a file is copied only if it matches at least one `include:`;
@@ -38,7 +24,8 @@ backup).
   don't matter, the next reconcile brings everything back in sync.
 - **Unmounted volumes**: missing destination → `pending` state with exponential
   backoff (1s → 60s cap), then a reconcile once the mount is back.
-- **launchd at boot**: an agent with `RunAtLoad` + `KeepAlive` keeps the process
+- **launchd (macOS) or systemd (Linux) at boot**: an agent with `RunAtLoad` +
+  `KeepAlive` (or `WantedBy=default.target` + `Restart=always`) keeps the process
   alive and restarts it if it dies.
 - **`.sync` carries rules only, destinations live only in `~/.safekeep`**: a
   `.sync` file can neither add nor remove destinations (a `dest:` line is an
@@ -53,27 +40,31 @@ pipx install safekeep     # recommended for a CLI
 pip install safekeep
 ```
 
-**Requirements**: macOS, Python >= 3.9 and
+**Requirements**: macOS or Linux (POSIX with systemd), Python >= 3.9 and
 [fswatch](https://github.com/emcrisostomo/fswatch):
 
 ```bash
-brew install fswatch
+brew install fswatch      # macOS
+sudo pacman -S fswatch    # Arch / Omarchy
+sudo apt install fswatch  # Debian / Ubuntu
+sudo dnf install fswatch  # Fedora
 ```
 
-The **launchd agent** (daemon at boot) is installed from a checkout of this
-repository with `./install.sh` — not from the wheel — see
-[Agent (launchd)](#agent-launchd) below.
+The **agent** (daemon at boot: launchd on macOS, a systemd *user unit* on Linux)
+is installed from a checkout of this repository with `./install.sh` — not from
+the wheel — see [Agent](#agent) below.
 
-## Agent (launchd)
+## Agent
 
 ```bash
-git clone https://gitlab.com/foxhound87/safekeep.git
+git clone https://github.com/foxhound87/safekeep.git
 cd safekeep
 
-# only external dependency, if not installed yet
-brew install fswatch
+# only external dependency, if not installed yet (see the per-OS list above)
+brew install fswatch      # macOS — the script suggests the right command on Linux
 
-# copies the example into ~/.safekeep, renders the plist, runs preflight checks
+# copies the example into ~/.safekeep, renders the plist / systemd unit,
+# runs preflight checks
 bash install.sh
 ```
 
@@ -88,12 +79,21 @@ Then:
 3. load the agent:
 
 ```bash
+# macOS (launchd)
 launchctl bootstrap gui/$(id -u) ~/Library/LaunchAgents/com.safekeep.agent.plist
 # unload with: launchctl bootout gui/$(id -u)/com.safekeep.agent
+
+# Linux (systemd user unit)
+systemctl --user enable --now safekeep
+# status with: systemctl --user status safekeep
+# logs with:   journalctl --user -u safekeep -f
+# unload with: systemctl --user disable --now safekeep
+# start at boot without a login session: loginctl enable-linger $USER
 ```
 
-Once you have granted TCC/FDA (Full Disk Access) permissions to the Python
-interpreter and to `fswatch`, run `safekeep doctor` for diagnostics.
+On macOS, once you have granted TCC/FDA (Full Disk Access) permissions to the
+Python interpreter and to `fswatch`, run `safekeep doctor` for diagnostics. On
+Linux the same command checks the `inotify` watch limit instead.
 
 ## Quickstart
 
@@ -157,7 +157,7 @@ safekeep <command> [--config PATH] [-v]
 | `run` | daemon: initial reconcile, fswatch loop, event dispatch, 24h timer |
 | `sync-once [--dry-run] [--project PATH] [--prune]` | a single pass: walks the source and copies whatever differs (`--dry-run` only prints what it would copy; `--prune` also removes dest files whose source still exists but is no longer included) |
 | `status` | read-only: config, sources, discovered projects with N rules, destination states |
-| `doctor` | diagnostics: config, fswatch, TCC, launchd plist — exits non-zero if a fatal check fails |
+| `doctor` | diagnostics: config, fswatch + platform monitor, python, TCC/launchd plist (macOS), inotify limit and systemd unit (Linux) — exits non-zero if a fatal check fails |
 
 ## Tests
 
@@ -165,9 +165,12 @@ safekeep <command> [--config PATH] [-v]
 python3 -m unittest discover -s tests
 ```
 
-Stdlib (`unittest`) suite, zero dependencies: 156 tests covering the matcher,
-config, atomic copy, volumes, daemon, auto-discovery and CLI. `fswatch` is not
-needed to run the tests.
+Stdlib (`unittest`) suite, zero dependencies: 175 tests covering the matcher,
+config, atomic copy, volumes, daemon, auto-discovery, CLI and the POSIX
+portability layer (platform helper, per-OS fswatch monitor, systemd template).
+`fswatch` is not needed to run the suite — the few `doctor` checks that talk to
+the real binary are skipped when it's missing — but CI installs it so the
+Linux job exercises the real `inotify` monitor.
 
 ## Documentation
 

{safekeep-0.2.0 → safekeep-0.3.0}/pyproject.toml

@@ -6,25 +6,31 @@ build-backend = "setuptools.build_meta"
 [project]
 name = "safekeep"
 dynamic = ["version"]
-description = "Selective always-on backups for macOS: fswatch-driven copy of allow-listed files, never deletes"
+description = "Selective always-on backups for macOS and Linux: fswatch-driven copy of allow-listed files, never deletes"
 readme = "README.md"
 license = "MIT"
 license-files = ["LICENSE"]
 requires-python = ">=3.9"
-keywords = ["backup", "macos", "fswatch", "sync", "allow-list", "launchd"]
+keywords = ["backup", "macos", "linux", "fswatch", "sync", "allow-list", "launchd", "systemd"]
 classifiers = [
     "Development Status :: 4 - Beta",
     "Environment :: Console",
     "Intended Audience :: System Administrators",
     "Operating System :: MacOS",
+    "Operating System :: POSIX",
+    "Operating System :: POSIX :: Linux",
     "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.14",
     "Topic :: System :: Archiving :: Backup",
 ]
 # zero runtime dependencies: solo stdlib (fswatch è un binario esterno)
 
 [project.urls]
-Homepage = "https://gitlab.com/foxhound87/safekeep"
-Repository = "https://gitlab.com/foxhound87/safekeep"
+Repository = "https://github.com/foxhound87/safekeep"
+Homepage = "https://foxhound87.github.io/safekeep/"
+Documentation = "https://foxhound87.github.io/safekeep/"
 
 [project.scripts]
 safekeep = "safekeep.cli:main"

safekeep-0.3.0/safekeep/__init__.py

@@ -0,0 +1,6 @@
+"""safekeep — motore di backup event-driven per macOS e Linux (vedi SPEC.md)."""
+import logging
+
+logging.getLogger('safekeep').addHandler(logging.NullHandler())
+
+__version__ = '0.3.0'

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

@@ -1,7 +1,7 @@
 """CLI di safekeep: `run`, `sync-once`, `status` e `doctor` (SPEC.md §9).
 
 Entry point del package (`safekeep.cli:main`): `bin/safekeep.py` è solo lo
-shim che usano launchd e i test.
+shim che usano launchd/systemd e i test.
 """
 import argparse
 import os
@@ -12,13 +12,21 @@ import sys
 from safekeep.config import ConfigError, discover_projects, parse_sync
 from safekeep.copier import TMP_INFIX
 from safekeep.daemon import Daemon, setup_logging
+from safekeep.platform import (
+    INOTIFY_MIN_WATCHES,
+    fswatch_monitor,
+    inotify_limit,
+    install_hint,
+    is_darwin,
+    is_linux,
+)
 from safekeep.volumes import dest_state
 
 # Radice del repo quando si gira da checkout; in un install pip punta altrove
 # (site-packages) e i riferimenti a file del repo degradano (vedi cmd_doctor).
 REPO = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
 EXAMPLE = os.path.join(REPO, 'examples', 'safekeep.example')
-REPO_URL = 'https://gitlab.com/foxhound87/safekeep'
+REPO_URL = 'https://github.com/foxhound87/safekeep'
 
 
 def build_parser():
@@ -29,7 +37,7 @@ def build_parser():
 
     parser = argparse.ArgumentParser(
         prog='safekeep',
-        description='safekeep — backup event-driven per macOS (vedi SPEC.md)')
+        description='safekeep — backup event-driven per macOS e Linux (vedi SPEC.md)')
     sub = parser.add_subparsers(dest='comando', required=True)
     sub.add_parser('run', parents=[common],
                    help='daemon: reconcile iniziale + watch fswatch + dispatch eventi + timer 24h')
@@ -45,7 +53,9 @@ def build_parser():
     sub.add_parser('status', parents=[common],
                    help='config, progetti e stato delle dest — sola lettura')
     sub.add_parser('doctor', parents=[common],
-                   help='diagnostica: config, fswatch, TCC, plist — exit ≠ 0 se un check fatale fallisce')
+                   help='diagnostica: config, fswatch + monitor di piattaforma, python, '
+                        'TCC/plist (macOS), inotify/systemd (Linux) — exit ≠ 0 se un check '
+                        'fatale fallisce')
     return parser
 
 
@@ -186,7 +196,7 @@ def cmd_doctor(args):
 
     exe = shutil.which('fswatch')
     if exe is None:
-        out(False, 'fswatch non trovato — installa con: brew install fswatch',
+        out(False, f'fswatch non trovato — installa con: {install_hint()}',
             is_fatal=True)
     else:
         version = None
@@ -200,31 +210,50 @@ def cmd_doctor(args):
         out(version is not None,
             f'fswatch: {version}' if version else 'fswatch --version senza output',
             is_fatal=True)
+        # monitor atteso per piattaforma (SPEC.md §14.2/§14.4)
+        expected = fswatch_monitor()
         try:
             monitors = subprocess.run([exe, '-M'], capture_output=True,
                                       text=True, timeout=15)
-            has_fsevents = 'fsevents_monitor' in monitors.stdout
+            present = expected in monitors.stdout
         except (OSError, subprocess.SubprocessError):
-            has_fsevents = False
-        out(has_fsevents,
-            'fswatch monitor: fsevents_monitor presente' if has_fsevents else
-            'fswatch monitor: fsevents_monitor ASSENTE in `fswatch -M`',
+            present = False
+        out(present,
+            f'fswatch monitor: {expected} presente' if present else
+            f'fswatch monitor: {expected} ASSENTE in `fswatch -M`',
             is_fatal=True)
 
     out(sys.version_info >= (3, 9),
         f'python {sys.version.split()[0]} (≥ 3.9)', is_fatal=True)
 
-    docs = os.path.expanduser('~/Documents')
-    if not os.path.isdir(docs):
-        out(True, 'TCC (Transparency, Consent and Control): ~/Documents assente — probe saltato')
-    else:
-        try:
-            os.listdir(docs)
-        except PermissionError:
-            out(False, 'TCC: PermissionError su ~/Documents — serve FDA '
-                       '(Full Disk Access) per i progetti in cartelle protette')
+    # Linux: il limite di watch di inotify è il rischio #1 sugli alberi grandi
+    # (SPEC.md §14.4) — informativo, NON fatale
+    if is_linux():
+        limit = inotify_limit()
+        if limit is None:
+            out(True, 'inotify: limite di watch non leggibile — check saltato')
+        elif limit < INOTIFY_MIN_WATCHES:
+            out(False, f'inotify: fs.inotify.max_user_watches={limit} '
+                       f'(< {INOTIFY_MIN_WATCHES}) — su alberi grandi (~25k file) i '
+                       'watch finiscono: sudo sysctl -w fs.inotify.max_user_watches=524288 '
+                       '— warning non fatale')
+        else:
+            out(True, f'inotify: fs.inotify.max_user_watches={limit} '
+                      f'(≥ {INOTIFY_MIN_WATCHES})')
+
+    # TCC (Transparency, Consent and Control) è un meccanismo di macOS (SPEC.md §11)
+    if is_darwin():
+        docs = os.path.expanduser('~/Documents')
+        if not os.path.isdir(docs):
+            out(True, 'TCC (Transparency, Consent and Control): ~/Documents assente — probe saltato')
         else:
-            out(True, 'TCC: ~/Documents leggibile')
+            try:
+                os.listdir(docs)
+            except PermissionError:
+                out(False, 'TCC: PermissionError su ~/Documents — serve FDA '
+                           '(Full Disk Access) per i progetti in cartelle protette')
+            else:
+                out(True, 'TCC: ~/Documents leggibile')
 
     if cfg is not None:
         residui = [os.path.join(dirpath, name)
@@ -236,19 +265,37 @@ def cmd_doctor(args):
             'residui *.safekeep.tmp.*: nessuno' if not residui else
             'residui *.safekeep.tmp.*: ' + ', '.join(residui))
 
-    plist = os.path.expanduser('~/Library/LaunchAgents/com.safekeep.agent.plist')
-    if not os.path.exists(plist):
-        out(True, 'plist non installato (nessun agent da validare)')
-    elif shutil.which('plutil') is None:
-        out(True, 'plutil assente — lint del plist saltato')
+    if is_darwin():
+        plist = os.path.expanduser('~/Library/LaunchAgents/com.safekeep.agent.plist')
+        if not os.path.exists(plist):
+            out(True, 'plist non installato (nessun agent da validare)')
+        elif shutil.which('plutil') is None:
+            out(True, 'plutil assente — lint del plist saltato')
+        else:
+            try:
+                lint = subprocess.run(['plutil', '-lint', plist],
+                                      capture_output=True, text=True, timeout=15)
+                detail = (lint.stdout + lint.stderr).strip() or plist
+                out(lint.returncode == 0, f'plist lint: {detail}', is_fatal=True)
+            except (OSError, subprocess.SubprocessError) as e:
+                out(False, f'plist lint non eseguibile: {e}', is_fatal=True)
     else:
-        try:
-            lint = subprocess.run(['plutil', '-lint', plist],
-                                  capture_output=True, text=True, timeout=15)
-            detail = (lint.stdout + lint.stderr).strip() or plist
-            out(lint.returncode == 0, f'plist lint: {detail}', is_fatal=True)
-        except (OSError, subprocess.SubprocessError) as e:
-            out(False, f'plist lint non eseguibile: {e}', is_fatal=True)
+        # Linux: user unit systemd al posto del plist (SPEC.md §14.3)
+        unit = os.path.expanduser('~/.config/systemd/user/safekeep.service')
+        if not os.path.exists(unit):
+            out(True, 'unit systemd non installata (nessun agent da validare)')
+        else:
+            try:
+                with open(unit, encoding='utf-8') as fh:
+                    text = fh.read()
+            except (OSError, UnicodeError) as e:
+                out(False, f'unit systemd illeggibile: {unit}: {e}', is_fatal=True)
+            else:
+                if '__REPO__' in text or '__PYTHON__' in text:
+                    out(False, f'unit systemd: {unit} contiene ancora i placeholder '
+                               'del template — rilancia install.sh', is_fatal=True)
+                else:
+                    out(True, f'unit systemd: {unit}')
 
     return 1 if fatal else 0
 

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

@@ -4,7 +4,8 @@
 Un solo processo, nessun thread: `step()` fa `select` su stdout di fswatch con
 timeout pari alla scadenza più vicina (reconcile giornaliero, retry dest
 absent, respawn fswatch). Le regex `-e` sono un pre-filtro grezzo: la verità
-su cosa copiare resta al matcher Python (SPEC.md §6.4).
+su cosa copiare resta al matcher Python (SPEC.md §6.4). Il monitor di fswatch
+viene da `safekeep.platform` (SPEC.md §14.1).
 """
 import logging
 import logging.handlers
@@ -26,6 +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 .volumes import backoff_schedule, dest_state, partition_dests
 
 log = logging.getLogger('safekeep')
@@ -34,7 +36,7 @@ FLOOD_LIMIT = 5000        # path per progetto in un batch → collapse a reconci
 DEDUP_WINDOW = 2.0        # secondi: stessa path entro la finestra → un solo evento
 RECONCILE_INTERVAL = 24 * 3600
 DEATH_WINDOW = 60         # finestra di conteggio delle morti di fswatch
-MAX_DEATHS = 5            # 5 morti in 60s → esco con codice ≠ 0 (launchd ci riprova)
+MAX_DEATHS = 5            # 5 morti in 60s → esco con codice ≠ 0 (l'init system ci riprova)
 RESPAWN_CAP = 60          # backoff respawn 1 → 60s
 
 SKIP = 'skip'
@@ -409,8 +411,9 @@ class Daemon:
     # --- fswatch ---------------------------------------------------------
 
     def fswatch_argv(self):
-        """`fswatch -0 -m fsevents_monitor -r -l 1.0 -e <regex> -- <roots>` (§6.4)."""
-        argv = ['fswatch', '-0', '-m', 'fsevents_monitor', '-r', '-l', '1.0']
+        """`fswatch -0 -m <monitor> -r -l 1.0 -e <regex> -- <roots>` (§6.4, §14.2):
+        il monitor è dichiarato per piattaforma, mai il default implicito."""
+        argv = ['fswatch', '-0', '-m', fswatch_monitor(), '-r', '-l', '1.0']
         for regex in self.exclude_regexes():
             argv += ['-e', regex]
         return argv + ['--'] + self.discovery_roots()[0]
@@ -462,8 +465,8 @@ class Daemon:
         self.deaths.append(now)
         if len(self.deaths) >= MAX_DEATHS:
             log.error('fswatch morto %d volte in %ds: esco con codice != 0 '
-                      '(launchd con KeepAlive ci riproverà)',
-                      len(self.deaths), DEATH_WINDOW)
+                      '(%s ci riproverà)',
+                      len(self.deaths), DEATH_WINDOW, init_system())
             self.fatal = True
             return
         if now - self.last_spawn >= DEATH_WINDOW:

safekeep-0.3.0/safekeep/platform.py

@@ -0,0 +1,57 @@
+"""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.2.0/README.md → safekeep-0.3.0/safekeep.egg-info/PKG-INFO

@@ -1,11 +1,41 @@
+Metadata-Version: 2.4
+Name: safekeep
+Version: 0.3.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
+Project-URL: Homepage, https://foxhound87.github.io/safekeep/
+Project-URL: Documentation, https://foxhound87.github.io/safekeep/
+Keywords: backup,macos,linux,fswatch,sync,allow-list,launchd,systemd
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: System Administrators
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: POSIX
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: System :: Archiving :: Backup
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
 # safekeep
 
-**Selective always-on backups for macOS**: watches source folders with
+[![PyPI](https://img.shields.io/pypi/v/safekeep)](https://pypi.org/project/safekeep/)
+[![Python](https://img.shields.io/pypi/pyversions/safekeep)](https://pypi.org/project/safekeep/)
+
+**Selective always-on backups for macOS and Linux**: watches source folders with
 [fswatch](https://github.com/emcrisostomo/fswatch) and copies only the files you
 chose to their destinations — an **allow-list** model that **never deletes**
 anything in the backup (a file removed or renamed at the source stays in the
 backup).
 
+Documentation: https://foxhound87.github.io/safekeep/
+
 ## Features
 
 - **Allow-list**: a file is copied only if it matches at least one `include:`;
@@ -19,7 +49,8 @@ backup).
   don't matter, the next reconcile brings everything back in sync.
 - **Unmounted volumes**: missing destination → `pending` state with exponential
   backoff (1s → 60s cap), then a reconcile once the mount is back.
-- **launchd at boot**: an agent with `RunAtLoad` + `KeepAlive` keeps the process
+- **launchd (macOS) or systemd (Linux) at boot**: an agent with `RunAtLoad` +
+  `KeepAlive` (or `WantedBy=default.target` + `Restart=always`) keeps the process
   alive and restarts it if it dies.
 - **`.sync` carries rules only, destinations live only in `~/.safekeep`**: a
   `.sync` file can neither add nor remove destinations (a `dest:` line is an
@@ -34,27 +65,31 @@ pipx install safekeep     # recommended for a CLI
 pip install safekeep
 ```
 
-**Requirements**: macOS, Python >= 3.9 and
+**Requirements**: macOS or Linux (POSIX with systemd), Python >= 3.9 and
 [fswatch](https://github.com/emcrisostomo/fswatch):
 
 ```bash
-brew install fswatch
+brew install fswatch      # macOS
+sudo pacman -S fswatch    # Arch / Omarchy
+sudo apt install fswatch  # Debian / Ubuntu
+sudo dnf install fswatch  # Fedora
 ```
 
-The **launchd agent** (daemon at boot) is installed from a checkout of this
-repository with `./install.sh` — not from the wheel — see
-[Agent (launchd)](#agent-launchd) below.
+The **agent** (daemon at boot: launchd on macOS, a systemd *user unit* on Linux)
+is installed from a checkout of this repository with `./install.sh` — not from
+the wheel — see [Agent](#agent) below.
 
-## Agent (launchd)
+## Agent
 
 ```bash
-git clone https://gitlab.com/foxhound87/safekeep.git
+git clone https://github.com/foxhound87/safekeep.git
 cd safekeep
 
-# only external dependency, if not installed yet
-brew install fswatch
+# only external dependency, if not installed yet (see the per-OS list above)
+brew install fswatch      # macOS — the script suggests the right command on Linux
 
-# copies the example into ~/.safekeep, renders the plist, runs preflight checks
+# copies the example into ~/.safekeep, renders the plist / systemd unit,
+# runs preflight checks
 bash install.sh
 ```
 
@@ -69,12 +104,21 @@ Then:
 3. load the agent:
 
 ```bash
+# macOS (launchd)
 launchctl bootstrap gui/$(id -u) ~/Library/LaunchAgents/com.safekeep.agent.plist
 # unload with: launchctl bootout gui/$(id -u)/com.safekeep.agent
+
+# Linux (systemd user unit)
+systemctl --user enable --now safekeep
+# status with: systemctl --user status safekeep
+# logs with:   journalctl --user -u safekeep -f
+# unload with: systemctl --user disable --now safekeep
+# start at boot without a login session: loginctl enable-linger $USER
 ```
 
-Once you have granted TCC/FDA (Full Disk Access) permissions to the Python
-interpreter and to `fswatch`, run `safekeep doctor` for diagnostics.
+On macOS, once you have granted TCC/FDA (Full Disk Access) permissions to the
+Python interpreter and to `fswatch`, run `safekeep doctor` for diagnostics. On
+Linux the same command checks the `inotify` watch limit instead.
 
 ## Quickstart
 
@@ -138,7 +182,7 @@ safekeep <command> [--config PATH] [-v]
 | `run` | daemon: initial reconcile, fswatch loop, event dispatch, 24h timer |
 | `sync-once [--dry-run] [--project PATH] [--prune]` | a single pass: walks the source and copies whatever differs (`--dry-run` only prints what it would copy; `--prune` also removes dest files whose source still exists but is no longer included) |
 | `status` | read-only: config, sources, discovered projects with N rules, destination states |
-| `doctor` | diagnostics: config, fswatch, TCC, launchd plist — exits non-zero if a fatal check fails |
+| `doctor` | diagnostics: config, fswatch + platform monitor, python, TCC/launchd plist (macOS), inotify limit and systemd unit (Linux) — exits non-zero if a fatal check fails |
 
 ## Tests
 
@@ -146,9 +190,12 @@ safekeep <command> [--config PATH] [-v]
 python3 -m unittest discover -s tests
 ```
 
-Stdlib (`unittest`) suite, zero dependencies: 156 tests covering the matcher,
-config, atomic copy, volumes, daemon, auto-discovery and CLI. `fswatch` is not
-needed to run the tests.
+Stdlib (`unittest`) suite, zero dependencies: 175 tests covering the matcher,
+config, atomic copy, volumes, daemon, auto-discovery, CLI and the POSIX
+portability layer (platform helper, per-OS fswatch monitor, systemd template).
+`fswatch` is not needed to run the suite — the few `doctor` checks that talk to
+the real binary are skipped when it's missing — but CI installs it so the
+Linux job exercises the real `inotify` monitor.
 
 ## Documentation
 

{safekeep-0.2.0 → safekeep-0.3.0}/safekeep.egg-info/SOURCES.txt

@@ -7,6 +7,7 @@ safekeep/config.py
 safekeep/copier.py
 safekeep/daemon.py
 safekeep/matcher.py
+safekeep/platform.py
 safekeep/volumes.py
 safekeep.egg-info/PKG-INFO
 safekeep.egg-info/SOURCES.txt
@@ -18,4 +19,5 @@ tests/test_config.py
 tests/test_copier.py
 tests/test_daemon.py
 tests/test_matcher.py
+tests/test_platform.py
 tests/test_volumes.py

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

@@ -2,16 +2,29 @@
 
 Ogni run è un subprocess con HOME finto: niente scritture nella home reale.
 """
+import argparse
+import contextlib
+import io
 import os
 import shutil
 import subprocess
 import sys
 import tempfile
 import unittest
+from unittest import mock
+
+from safekeep import cli
+from safekeep.platform import fswatch_monitor
 
 REPO = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
 CLI = os.path.join(REPO, 'bin', 'safekeep.py')
 
+# Check di `doctor` condivisi da tutte le piattaforme (SPEC.md §9)
+BASE_MARKERS = ('config', 'dest non annidate', 'fswatch', 'python', 'residui')
+# SPEC.md §14.4: TCC e plist sono Darwin-only, inotify e unit systemd Linux-only
+DARWIN_MARKERS = ('TCC', 'plist')
+LINUX_MARKERS = ('inotify', 'unit systemd')
+
 
 def write(path, text=''):
     os.makedirs(os.path.dirname(path), exist_ok=True)
@@ -61,13 +74,54 @@ class DoctorTest(CliTestCase):
     def test_doctor_gira_tutti_i_check(self):
         r = self.cli('doctor', '--config', self.cfg)
         self.assertIn(r.returncode, (0, 1), r.stdout + r.stderr)
-        for marker in ('config', 'dest non annidate', 'fswatch', 'python',
-                       'TCC', 'residui', 'plist'):
+        markers = BASE_MARKERS + (DARWIN_MARKERS if sys.platform == 'darwin'
+                                  else LINUX_MARKERS)
+        for marker in markers:
             self.assertIn(marker, r.stdout, f'check mancante: {marker}')
         for line in r.stdout.splitlines():
             if line.strip():
                 self.assertIn(line[0], ('✔', '✗'), f'riga senza esito: {line!r}')
 
+    def test_doctor_monitor_della_piattaforma(self):
+        # SPEC.md §14.4: il monitor atteso va cercato in `fswatch -M`
+        if shutil.which('fswatch') is None:
+            self.skipTest('fswatch non installato')
+        r = self.cli('doctor', '--config', self.cfg)
+        self.assertIn(f'fswatch monitor: {fswatch_monitor()} presente', r.stdout)
+
+    @unittest.skipUnless(sys.platform == 'darwin', 'check TCC macOS')
+    def test_doctor_tcc_e_darwin_only(self):
+        r = self.cli('doctor', '--config', self.cfg)
+        self.assertIn('TCC', r.stdout)
+
+    @unittest.skipIf(sys.platform == 'darwin', 'check inotify Linux')
+    def test_doctor_inotify_e_linux_only(self):
+        r = self.cli('doctor', '--config', self.cfg)
+        self.assertIn('inotify', r.stdout)
+        self.assertNotIn('TCC', r.stdout, 'TCC è un meccanismo di macOS')
+        for line in r.stdout.splitlines():
+            if line.startswith('✗') and 'inotify' in line:
+                self.assertIn('warning non fatale', line)
+
+    @unittest.skipUnless(shutil.which('fswatch'), 'fswatch non installato')
+    def test_doctor_limite_basso_non_e_fatale(self):
+        """SPEC.md §14.4: su Linux il limite di watch basso è informativo —
+        doctor esce 0, non 1. I rami Linux si esercitano patchando l'helper,
+        senza girare su Linux."""
+        args = argparse.Namespace(config=self.cfg, v=False)
+        buf = io.StringIO()
+        with mock.patch.object(cli, 'is_linux', return_value=True), \
+                mock.patch.object(cli, 'is_darwin', return_value=False), \
+                mock.patch.object(cli, 'inotify_limit', return_value=8192), \
+                contextlib.redirect_stdout(buf):
+            code = cli.cmd_doctor(args)
+        out = buf.getvalue()
+        self.assertIn('max_user_watches=8192', out)
+        self.assertIn('warning non fatale', out)
+        self.assertIn('unit systemd', out)
+        self.assertNotIn('TCC', out, 'TCC è un meccanismo di macOS')
+        self.assertEqual(code, 0, out)
+
     def test_doctor_config_invalido_esce_1(self):
         bad = write(os.path.join(self.tmp, 'bad.cfg'), 'riga nuda invalida\n')
         r = self.cli('doctor', '--config', bad)

{safekeep-0.2.0 → safekeep-0.3.0}/tests/test_daemon.py

@@ -413,7 +413,7 @@ class PlanBatchTest(unittest.TestCase):
 
 
 class FswatchArgvTest(unittest.TestCase):
-    def test_argv_esatto_dallo_spec(self):
+    def _daemon(self):
         tmp = tempfile.mkdtemp()
         self.addCleanup(shutil.rmtree, tmp, ignore_errors=True)
         src = os.path.join(tmp, 'src')
@@ -424,15 +424,30 @@ class FswatchArgvTest(unittest.TestCase):
         daemon = Daemon(cfg_path)
         daemon.load_config()
         daemon.load_projects()
+        return daemon, src
+
+    def test_argv_esatto_dallo_spec(self):
+        daemon, src = self._daemon()
         argv = daemon.fswatch_argv()
-        self.assertEqual(argv[:7],
-                         ['fswatch', '-0', '-m', 'fsevents_monitor', '-r', '-l', '1.0'])
+        # posizioni fisse: solo il monitor (-m) è per-piattaforma (SPEC §14.2)
+        self.assertEqual(argv[:3], ['fswatch', '-0', '-m'])
+        self.assertIn(argv[3], ('fsevents_monitor', 'inotify_monitor'))
+        self.assertEqual(argv[4:7], ['-r', '-l', '1.0'])
         regexes = [argv[i + 1] for i, a in enumerate(argv) if a == '-e']
         self.assertTrue(regexes)
         self.assertTrue(any(re.search(rx, '/qualcuno/node_modules/x') for rx in regexes))
         self.assertTrue(any('skipme/' in rx for rx in regexes))
         self.assertEqual(argv[argv.index('--') + 1:], [src])
 
+    def test_monitor_dichiarato_per_piattaforma(self):
+        # SPEC §14.1/§14.2: il monitor è esplicito su entrambi i rami, letto
+        # a chiamata — così entrambi si testano anche girando su macOS
+        daemon, _ = self._daemon()
+        with mock.patch('sys.platform', 'darwin'):
+            self.assertEqual(daemon.fswatch_argv()[3], 'fsevents_monitor')
+        with mock.patch('sys.platform', 'linux'):
+            self.assertEqual(daemon.fswatch_argv()[3], 'inotify_monitor')
+
 
 class WalkDirTest(TmpTestCase):
     """Mini-walk su una dir appena creata: filtro allow-list sui file figli."""

safekeep-0.3.0/tests/test_platform.py

@@ -0,0 +1,150 @@
+"""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()

safekeep-0.2.0/safekeep/__init__.py

@@ -1,6 +0,0 @@
-"""safekeep — motore di backup event-driven per macOS (vedi SPEC.md)."""
-import logging
-
-logging.getLogger('safekeep').addHandler(logging.NullHandler())
-
-__version__ = '0.2.0'