remarkablesync 2.0.2__tar.gz → 2.0.3__tar.gz

{remarkablesync-2.0.2/remarkablesync.egg-info → remarkablesync-2.0.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: remarkablesync
-Version: 2.0.2
+Version: 2.0.3
 Summary: Backup and convert reMarkable tablet notebooks to PDF
 Home-page: https://github.com/JeffSteinbok/RemarkableSync
 Author: Jeff Steinbok

{remarkablesync-2.0.2 → remarkablesync-2.0.3}/RemarkableSync.py

@@ -590,7 +590,13 @@ def main():
 
     if not has_command and '--version' not in sys.argv and '--help' not in sys.argv:
         # Load config to decide which pipeline to run
-        from src.config import load_config
+        from src.config import get_config_path, load_config
+
+        if not get_config_path().exists():
+            script_name = Path(sys.argv[0]).name or "RemarkableSync.py"
+            click.echo("[ERROR] No configuration found.", err=True)
+            click.echo(f"Run: python {script_name} config", err=True)
+            sys.exit(1)
 
         cfg = load_config()
         actions = cfg.get("sync_actions", [])
@@ -638,4 +644,3 @@ def main():
 
 if __name__ == "__main__":
     main()
-

{remarkablesync-2.0.2 → remarkablesync-2.0.3/remarkablesync.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: remarkablesync
-Version: 2.0.2
+Version: 2.0.3
 Summary: Backup and convert reMarkable tablet notebooks to PDF
 Home-page: https://github.com/JeffSteinbok/RemarkableSync
 Author: Jeff Steinbok

{remarkablesync-2.0.2 → remarkablesync-2.0.3}/remarkablesync.egg-info/SOURCES.txt

@@ -54,10 +54,12 @@ tests/conftest.py
 tests/generate_test_assets.py
 tests/mock_ai_provider.py
 tests/mock_connection.py
+tests/test_agent_issues.py
 tests/test_ai_providers.py
 tests/test_auth_device_flow.py
 tests/test_basic.py
 tests/test_config.py
+tests/test_config_command.py
 tests/test_console.py
 tests/test_hybrid_converter.py
 tests/test_keyring_store.py

{remarkablesync-2.0.2 → remarkablesync-2.0.3}/src/__version__.py

@@ -1,4 +1,4 @@
 """Version information for RemarkableSync."""
 
-__version__ = "2.0.2"
+__version__ = "2.0.3"
 __repository__ = "https://github.com/JeffSteinbok/RemarkableSync"

{remarkablesync-2.0.2 → remarkablesync-2.0.3}/src/backup/backup_manager.py

@@ -48,6 +48,8 @@ class ReMarkableBackup:  # pylint: disable=too-many-instance-attributes
         host: str = "10.11.99.1",
         use_wifi: bool = False,
         wifi_host: str = "",
+        pre_sync_command: str = "",
+        post_sync_command: str = "",
     ):
         """Initialize backup orchestrator.
 
@@ -57,22 +59,24 @@ class ReMarkableBackup:  # pylint: disable=too-many-instance-attributes
             host: Tablet IP/hostname (USB default: 10.11.99.1)
             use_wifi: Connect via Wi-Fi instead of USB
             wifi_host: Wi-Fi IP/hostname (auto-discovered if empty)
+            pre_sync_command: Shell command to run before SSH connects.
+            post_sync_command: Shell command to run after SSH disconnects.
         """
         self.backup_dir = backup_dir
-        self.files_dir = backup_dir / "Notebooks"  # Clean folder name
-        self.templates_dir = backup_dir / "Templates"  # Clean folder name
+        self.files_dir = backup_dir / "Notebooks"
+        self.templates_dir = backup_dir / "Templates"
         self.metadata_file = backup_dir / "sync_metadata.json"
 
-        # Create directories
         self.files_dir.mkdir(parents=True, exist_ok=True)
         self.templates_dir.mkdir(parents=True, exist_ok=True)
 
-        # Initialize components
         self.connection = ReMarkableConnection(
             password=password,
             host=host,
             use_wifi=use_wifi,
             wifi_host=wifi_host,
+            pre_sync_command=pre_sync_command,
+            post_sync_command=post_sync_command,
         )
         self.metadata = FileMetadata(self.metadata_file)
 
@@ -173,23 +177,13 @@ class ReMarkableBackup:  # pylint: disable=too-many-instance-attributes
         print(f"  Found {len(allowed)} notebooks in selected folders")
         return allowed
 
-    def backup_files(
+    def _do_backup_files(
         self,
     ) -> Tuple[bool, Set[str], Dict[str, Set[str]]]:  # pylint: disable=too-many-branches
-        """Backup files from ReMarkable tablet.
-
-        Returns:
-            Tuple of (success, set of notebook UUIDs that were updated,
-            dict mapping notebook UUID to set of changed page IDs)
-        """
+        """Backup files from ReMarkable tablet. Assumes connection is already open."""
         logging.info("Starting file backup...")
-        print("  Connecting to tablet...")
-
-        if not self.connection.connect():
-            return False, set(), {}
 
         try:
-            # Resolve folder filter before listing files
             allowed_uuids = self._resolve_allowed_uuids()
 
             # Get list of remote files
@@ -316,23 +310,10 @@ class ReMarkableBackup:  # pylint: disable=too-many-instance-attributes
             logging.error("Backup failed: %s", e)
             return False, set(), {}
 
-        finally:
-            self.connection.disconnect()
-
-    def backup_templates(self) -> bool:
-        """Backup template files from ReMarkable tablet.
-
-        Templates are stored in /usr/share/remarkable/templates/ and include
-        PNG/SVG template images and a templates.json configuration file.
-
-        Returns:
-            bool: True if successful, False otherwise
-        """
+    def _do_backup_templates(self) -> bool:
+        """Backup template files from ReMarkable tablet. Assumes connection is already open."""
         logging.info("Starting template backup...")
 
-        if not self.connection.connect():
-            return False
-
         try:
             # Get list of template files
             remote_files = self.connection.list_files(self.remote_templates_dir)
@@ -387,9 +368,6 @@ class ReMarkableBackup:  # pylint: disable=too-many-instance-attributes
             logging.error("Template backup failed: %s", e)
             return False
 
-        finally:
-            self.connection.disconnect()
-
     def find_notebooks(self) -> List[Dict]:
         """Find and parse notebook metadata.
 
@@ -465,7 +443,7 @@ class ReMarkableBackup:  # pylint: disable=too-many-instance-attributes
         force_convert_all: bool = False,
         convert_to_pdf: bool = False,
         backup_templates: bool = True,
-    ) -> bool:
+    ) -> Tuple[bool, Set[str], Dict[str, Set[str]]]:
         """Run complete backup process with optional PDF conversion.
 
         Args:
@@ -474,27 +452,34 @@ class ReMarkableBackup:  # pylint: disable=too-many-instance-attributes
             backup_templates: If True, backup template files from the tablet (default: True)
 
         Returns:
-            bool: True if backup successful, False otherwise
+            Tuple of (success, updated_notebook_uuids, updated_pages)
         """
         logging.info("Starting ReMarkable backup process")
 
-        # Backup files and get list of updated notebooks
-        success, updated_notebook_uuids, updated_pages = self.backup_files()
-        if not success:
-            return False
+        if not self.connection.connect():
+            return False, set(), {}
+
+        updated_notebook_uuids: Set[str] = set()
+        updated_pages: Dict[str, Set[str]] = {}
 
-        # Backup templates if requested
-        if backup_templates:
-            templates_success = self.backup_templates()
-            if not templates_success:
-                logging.warning("Template backup failed, but continuing with main backup")
+        try:
+            success, updated_notebook_uuids, updated_pages = self._do_backup_files()
+            if not success:
+                return False, set(), {}
+
+            if backup_templates:
+                templates_success = self._do_backup_templates()
+                if not templates_success:
+                    logging.warning("Template backup failed, but continuing with main backup")
+        finally:
+            self.connection.disconnect()
 
-        # Automatic PDF conversion using hybrid converter
         if convert_to_pdf:
-            return self.run_pdf_conversion(updated_notebook_uuids, force_convert_all, updated_pages)
+            ok = self.run_pdf_conversion(updated_notebook_uuids, force_convert_all, updated_pages)
+            return ok, updated_notebook_uuids, updated_pages
 
         logging.info("Backup process completed successfully")
-        return True
+        return True, updated_notebook_uuids, updated_pages
 
     def run_pdf_conversion(
         self,

{remarkablesync-2.0.2 → remarkablesync-2.0.3}/src/backup/connection.py

@@ -19,6 +19,14 @@ import click
 import paramiko
 from scp import SCPClient
 
+from ..utils.console import print_error, print_success, print_warn
+
+# Suppress paramiko noise regardless of when setup_logging is called
+for _n in ("paramiko", "paramiko.transport", "paramiko.auth", "paramiko.channel"):
+    _l = logging.getLogger(_n)
+    _l.setLevel(logging.CRITICAL)
+    _l.propagate = False
+
 try:
     import keyring  # type: ignore
 
@@ -76,6 +84,8 @@ class ReMarkableConnection:
         password: str | None = None,
         use_wifi: bool = False,
         wifi_host: str = "",
+        pre_sync_command: str = "",
+        post_sync_command: str = "",
     ):
         """Initialize connection parameters.
 
@@ -89,6 +99,8 @@ class ReMarkableConnection:
                       Falls back to USB if *wifi_host* is empty.
             wifi_host: IP address or hostname of the tablet on the local
                        network.  Ignored when *use_wifi* is False.
+            pre_sync_command: Shell command to run before SSH connects.
+            post_sync_command: Shell command to run after SSH disconnects.
         """
         # Resolve effective host
         if use_wifi:
@@ -107,6 +119,8 @@ class ReMarkableConnection:
         self.scp_client = None
         self.password = password
         self.password_saved = False
+        self.pre_sync_command = pre_sync_command.strip()
+        self.post_sync_command = post_sync_command.strip()
 
     def get_saved_password(self) -> str | None:
         """Get saved password from system keyring.
@@ -188,13 +202,22 @@ class ReMarkableConnection:
     def connect(self) -> bool:
         """Establish SSH connection to ReMarkable tablet.
 
-        Attempts multiple connection strategies with different timeout values
-        to handle various network conditions and tablet responsiveness.
-        Handles password retry logic if saved password fails.
+        Runs the pre-sync command (if configured) before opening the SSH
+        connection, and the post-sync command (if configured) in disconnect().
 
         Returns:
             bool: True if connection successful, False otherwise
         """
+        if self.pre_sync_command:
+            from ..utils import run_shell_command
+
+            print(f"  Running pre-sync: {self.pre_sync_command}")
+            rc = run_shell_command(self.pre_sync_command)
+            if rc != 0:
+                print_error(f"  ERR - Pre-sync command failed (exit {rc})")
+                return False
+            print_success("  OK - Pre-sync done")
+
         max_password_retries = 3
         password_attempt = 0
         used_saved_password = False
@@ -246,7 +269,7 @@ class ReMarkableConnection:
                         logging.warning("Authentication failed on attempt %d: %s", i + 1, e)
                         # Authentication failed - might be wrong password
                         if used_saved_password:
-                            print("\nSaved password appears to be incorrect.")
+                            print_warn("  WRN - Saved password appears to be incorrect.")
                             if click.confirm(
                                 "Would you like to enter a new password?", default=True
                             ):
@@ -263,13 +286,14 @@ class ReMarkableConnection:
                                 else:
                                     return False
                         else:
-                            # User-entered password was wrong
-                            print("\nAuthentication failed. Please check your password.")
+                            print_error(
+                                "  ERR - Authentication failed. Please check your password."
+                            )
                             self.password = None
                             password_attempt += 1
                             break
                     except (paramiko.SSHException, OSError) as e:
-                        logging.warning("Connection attempt %d failed: %s", i + 1, e)
+                        logging.debug("Connection attempt %d failed: %s", i + 1, e)
                         if self.ssh_client:
                             try:
                                 self.ssh_client.close()
@@ -278,28 +302,44 @@ class ReMarkableConnection:
                             self.ssh_client = paramiko.SSHClient()
                             self.ssh_client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
 
-                logging.error("All connection attempts failed")
+                logging.debug("All connection attempts failed")
+
+                print_error(
+                    f"  ERR - Connection to {self.host} failed. "
+                    "Check that the tablet is connected and try again."
+                )
                 return False
 
             except (paramiko.SSHException, OSError) as e:
-                logging.error("Failed to connect to ReMarkable: %s", e)
+                logging.debug("Failed to connect to ReMarkable: %s", e)
+                print_error(
+                    f"  ERR - Connection to {self.host} failed. "
+                    "Check that the tablet is connected and try again."
+                )
                 return False
 
-        print("\nMaximum password retry attempts reached.")
+        print_error("  ERR - Maximum password retry attempts reached.")
         return False
 
     def disconnect(self):
-        """Close SSH and SCP connections to ReMarkable tablet.
-
-        Safely closes both SCP and SSH client connections,
-        ensuring clean disconnection from the tablet.
-        """
+        """Close SSH and SCP connections to ReMarkable tablet."""
+        print("  Disconnecting...")
         if self.scp_client:
             self.scp_client.close()
         if self.ssh_client:
             self.ssh_client.close()
         logging.info("Disconnected from ReMarkable tablet")
 
+        if self.post_sync_command:
+            from ..utils import run_shell_command
+
+            print(f"  Running post-sync: {self.post_sync_command}")
+            rc = run_shell_command(self.post_sync_command)
+            if rc != 0:
+                print_error(f"  ERR - Post-sync command failed (exit {rc})")
+            else:
+                print_success("  OK - Post-sync done")
+
     def execute_command(self, command: str) -> Tuple[str, str, int]:
         """Execute command on ReMarkable tablet via SSH.
 

{remarkablesync-2.0.2 → remarkablesync-2.0.3}/src/commands/config_command.py

@@ -10,6 +10,7 @@ from typing import Any, Dict, List
 import click
 
 from src.config import SYNC_ACTIONS, load_config, save_config
+from src.utils.console import print_warn
 
 
 def run_config_command() -> int:
@@ -214,6 +215,7 @@ def run_config_command() -> int:
     # 7. Markdown export settings — OCR is implied when export is selected
     ocr_enabled = current.get("ocr_enabled", False)
     output_dir = current.get("output_dir", "")
+    embed_images = current.get("embed_images", True)
 
     if "ocr" in sync_actions:
         ocr_enabled = True
@@ -231,7 +233,6 @@ def run_config_command() -> int:
             click.echo(f"  Using default: {output_dir}")
 
         # 7b. Embed page images with Markdown?
-        embed_images = current.get("embed_images", True)
         embed_images = inquirer.confirm(
             message="Include page images alongside Markdown files?",
             default=embed_images,
@@ -352,13 +353,41 @@ def run_config_command() -> int:
             else:
                 click.echo("  Skipped. You can set ANTHROPIC_API_KEY env var instead.")
 
-    # 8. Connect to tablet and select folders
+    # 8. Pre/post-sync commands (optional)
+    pre_sync_command = current.get("pre_sync_command", "")
+    post_sync_command = current.get("post_sync_command", "")
+
+    click.echo()
+    click.echo("  Optional: shell commands to run before and after sync.")
+    click.echo("  Useful for disabling VPNs, network tools, etc. Leave blank to skip.")
+    click.echo()
+
+    pre_sync_command = (
+        inquirer.text(
+            message="Pre-sync command (blank=none):",
+            default=pre_sync_command,
+        ).execute()
+        or ""
+    )
+
+    post_sync_command = (
+        inquirer.text(
+            message="Post-sync command (blank=none):",
+            default=post_sync_command,
+        ).execute()
+        or ""
+    )
+
+    # 9. Connect to tablet and select folders
     click.echo()
     click.echo("  Connecting to tablet to discover folders...")
+
     folder_choices = _get_folder_choices_live(
         connection_mode,
         password,
         wifi_host,
+        pre_sync_command=pre_sync_command,
+        post_sync_command=post_sync_command,
     )
     folders: List[str] = []
 
@@ -378,7 +407,7 @@ def run_config_command() -> int:
             click.echo("Configuration cancelled.")
             return 0
     else:
-        click.echo("  Could not connect to tablet. Folder selection skipped.")
+        print_warn("  WRN - Could not connect to tablet. Folder selection skipped.")
         folders = current.get("folders", [])
 
     # Save configuration — preserve keys not managed by this wizard
@@ -397,6 +426,8 @@ def run_config_command() -> int:
             "embed_images": embed_images,
             "ai_provider": ai_provider,
             "ai_model": ai_model,
+            "pre_sync_command": pre_sync_command,
+            "post_sync_command": post_sync_command,
         }
     )
 
@@ -407,22 +438,26 @@ def run_config_command() -> int:
     click.echo("  Configuration saved!")
     click.echo("=" * 70)
     click.echo()
-    click.echo(f"  File:    {path}")
-    click.echo(f"  Mode:    {connection_mode.upper()}")
+    click.echo(f"  File:      {path}")
+    click.echo(f"  Mode:      {connection_mode.upper()}")
     if connection_mode == "wifi":
-        click.echo(f"  Host:    {wifi_host}")
-    click.echo(f"  Password: {'••••••••' if password else '(not set)'}")
-    click.echo(f"  Backup:  {backup_dir}")
+        click.echo(f"  Host:      {wifi_host}")
+    click.echo(f"  Password:  {'••••••••' if password else '(not set)'}")
+    click.echo(f"  Backup:    {backup_dir}")
     if pdf_dir:
-        click.echo(f"  PDFs:    {pdf_dir}")
-    click.echo(f"  Folders: {', '.join(folders) if folders else '(all)'}")
-    click.echo(f"  Actions: {', '.join(sync_actions)}")
+        click.echo(f"  PDFs:      {pdf_dir}")
+    click.echo(f"  Folders:   {', '.join(folders) if folders else '(all)'}")
+    click.echo(f"  Actions:   {', '.join(sync_actions)}")
     if ocr_enabled:
-        click.echo(f"  MD:      {output_dir}")
-        click.echo(f"  Images:  {'yes (_images/ folder)' if embed_images else 'no'}")
-        click.echo(f"  AI:      {ai_provider} ({ai_model})")
+        click.echo(f"  MD:        {output_dir}")
+        click.echo(f"  Images:    {'yes (_images/ folder)' if embed_images else 'no'}")
+        click.echo(f"  AI:        {ai_provider} ({ai_model})")
         has_token = bool(github_token or claude_api_key)
-        click.echo(f"  Token:   {'OK - saved in keyring' if has_token else '(not set)'}")
+        click.echo(f"  Token:     {'OK - saved in keyring' if has_token else '(not set)'}")
+    if pre_sync_command:
+        click.echo(f"  Pre:       {pre_sync_command}")
+    if post_sync_command:
+        click.echo(f"  Post:      {post_sync_command}")
     click.echo()
 
     return 0
@@ -473,7 +508,7 @@ def _enable_wifi_ssh(password: str) -> str:
     click.echo("  Connecting via USB...")
 
     if not conn.connect():
-        click.echo("  WRN - Could not connect via USB. Is the tablet plugged in?")
+        print_warn("  WRN - Could not connect via USB. Is the tablet plugged in?")
         return ""
 
     try:
@@ -508,7 +543,11 @@ def _enable_wifi_ssh(password: str) -> str:
 
 
 def _get_folder_choices_live(
-    connection_mode: str, password: str, wifi_host: str
+    connection_mode: str,
+    password: str,
+    wifi_host: str,
+    pre_sync_command: str = "",
+    post_sync_command: str = "",
 ) -> List[Dict[str, Any]]:
     """Connect to the tablet and discover top-level folders.
 
@@ -529,13 +568,14 @@ def _get_folder_choices_live(
         host=host,
         use_wifi=use_wifi,
         wifi_host=wifi_host,
+        pre_sync_command=pre_sync_command,
+        post_sync_command=post_sync_command,
     )
 
-    if not conn.connect():
-        click.echo("  WRN - Could not connect to tablet.")
-        return []
-
     try:
+        if not conn.connect():
+            print_warn("  WRN - Could not connect to tablet.")
+            return []
         xochitl = "/home/root/.local/share/remarkable/xochitl"
 
         # Use a single command to dump all metadata files efficiently

{remarkablesync-2.0.2 → remarkablesync-2.0.3}/src/commands/pipeline.py

@@ -101,6 +101,8 @@ def run_pipeline(
     # ------------------------------------------------------------------
     # Stage 1: Backup
     # ------------------------------------------------------------------
+    pre_sync_cmd = config.get("pre_sync_command", "").strip()
+    post_sync_cmd = config.get("post_sync_command", "").strip()
     updated_uuids: set = set()
     updated_pages: dict = {}
 
@@ -113,22 +115,29 @@ def run_pipeline(
             host=host,
             use_wifi=use_wifi,
             wifi_host=wifi_host,
+            pre_sync_command=pre_sync_cmd,
+            post_sync_command=post_sync_cmd,
         )
+        backup_ok = False
         try:
-            success, updated_uuids, updated_pages = backup_tool.backup_files()
+            success, updated_uuids, updated_pages = backup_tool.run_backup(
+                backup_templates=True,
+            )
             if not success:
                 print_error("  ERR - Backup failed.")
-                return 1
-            backup_tool.backup_templates()
-            print_success(f"  OK - Backed up ({len(updated_uuids)} notebooks updated)")
-            write_manifest(
-                backup_dir.parent / "updated_notebooks.txt",
-                sorted(updated_uuids),
-                "updated_notebooks",
-            )
+            else:
+                print_success(f"  OK - Backed up ({len(updated_uuids)} notebooks updated)")
+                write_manifest(
+                    backup_dir.parent / "updated_notebooks.txt",
+                    sorted(updated_uuids),
+                    "updated_notebooks",
+                )
+                backup_ok = True
         except Exception as exc:  # noqa: BLE001
             logging.error("Backup error: %s", exc)
             print_error(f"  ERR - Backup failed: {exc}")
+
+        if not backup_ok:
             return 1
     else:
         print("\n[1/3] Backup skipped (--skip-backup)")
@@ -211,8 +220,7 @@ def run_pipeline(
     # Discover notebooks and their folder paths
     all_items = find_notebooks(backup_dir)
     if not all_items:
-        print("      No notebooks found in backup directory.")
-        return 0
+        print("      No notebooks found in backup directory. Continuing to post-sync step.")
 
     org = organize_notebooks_by_structure(all_items, backup_dir)
     notebooks = org["documents_to_convert"]
@@ -281,4 +289,5 @@ def run_pipeline(
     print(f"  Markdown   : {exported} exported, {skipped} unchanged -> {output_dir.absolute()}")
     print(f"  Duration   : {mins}m {secs}s")
     print("=" * 70)
+
     return 0

{remarkablesync-2.0.2 → remarkablesync-2.0.3}/src/commands/sync_command.py

@@ -41,10 +41,14 @@ def run_sync_command(
     """
     import time as _time
 
+    from ..config import load_config
+
     log_dir = backup_dir.parent
     setup_logging(log_level, log_dir=log_dir)
     _start_time = _time.monotonic()
 
+    config = load_config()
+
     print("ReMarkable Sync (Backup + Convert)")
     print("=" * 70)
     print(f"Backup directory: {backup_dir.absolute()}")
@@ -60,12 +64,17 @@ def run_sync_command(
     if force_convert:
         print("Force convert: All notebooks will be converted")
 
+    # ------------------------------------------------------------------
+    # Backup + convert
+    # ------------------------------------------------------------------
     backup_tool = ReMarkableBackup(
         backup_dir,
         password=password,
         host=host,
         use_wifi=use_wifi,
         wifi_host=wifi_host,
+        pre_sync_command=config.get("pre_sync_command", "").strip(),
+        post_sync_command=config.get("post_sync_command", "").strip(),
     )
 
     try:
@@ -87,14 +96,15 @@ def run_sync_command(
             print(f"  Backup     : {backup_tool.files_dir}")
             if not skip_templates:
                 print(f"  Templates  : {backup_tool.templates_dir}")
-            from ..config import load_config
-
-            _cfg = load_config()
-            _pdf_dir = _cfg.get("pdf_dir", "")
+            _pdf_dir = config.get("pdf_dir", "")
             if _pdf_dir and Path(_pdf_dir).exists():
                 print(f"  PDFs       : {_pdf_dir}")
             print(f"  Duration   : {mins}m {secs}s")
             print("=" * 70)
+
+            # ------------------------------------------------------------------
+            # Post-sync command
+            # ------------------------------------------------------------------
             return 0
         else:
             print("\n[ERROR] Sync failed. Check logs for details.")

{remarkablesync-2.0.2 → remarkablesync-2.0.3}/src/config.py

@@ -57,6 +57,8 @@ DEFAULT_CONFIG: Dict[str, Any] = {
     "pdf_dir": "",
     "ai_provider": "github",
     "ai_model": "",
+    "pre_sync_command": "",
+    "post_sync_command": "",
 }
 
 # All available sync actions

{remarkablesync-2.0.2 → remarkablesync-2.0.3}/src/pdf_md_converter.py

@@ -513,7 +513,7 @@ class MarkdownExporter:
                 nb_pages = nb_page_counts[i]
                 progress.update(
                     task,
-                    description=f"{nb_name} (page 0 of {nb_pages})",
+                    description=f"{nb_name} (page 1 of {nb_pages})",
                 )
 
                 safe = sanitize_name(notebook["name"]) or f"notebook_{notebook['uuid'][:8]}"

{remarkablesync-2.0.2 → remarkablesync-2.0.3}/src/rm_pdf_converter.py

@@ -169,7 +169,7 @@ def run_conversion(
                     description=f"{_nb} (page {_pc[0] + 1} of {_nbt})",
                 )
 
-            progress.update(task, description=f"{nb_name} (page 0 of {nb_total})")
+            progress.update(task, description=f"{nb_name} (page 1 of {nb_total})")
 
             try:
                 notebook_changed_pages = None