mdify-cli 3.2.0__tar.gz → 3.3.0__tar.gz

{mdify_cli-3.2.0 → mdify_cli-3.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mdify-cli
-Version: 3.2.0
+Version: 3.3.0
 Summary: Convert PDFs and document images into structured Markdown for LLM workflows
 Author: tiroq
 License-Expression: MIT

{mdify_cli-3.2.0 → mdify_cli-3.3.0}/mdify/__init__.py

@@ -1,3 +1,3 @@
 """mdify - Convert documents to Markdown via Docling container."""
 
-__version__ = "3.2.0"
+__version__ = "3.3.0"

{mdify_cli-3.2.0 → mdify_cli-3.3.0}/mdify/cli.py

@@ -8,10 +8,10 @@ is lightweight and has no ML dependencies.
 """
 
 import argparse
-import asyncio
 import json
 import os
 import platform
+import shlex
 import shutil
 import subprocess
 import sys
@@ -273,14 +273,14 @@ def check_for_update(force: bool = False) -> None:
 
     _update_last_check_time()
 
+    from mdify.formatting import Colorizer
+    
     if not _compare_versions(__version__, remote_version):
         if force:
-            from mdify.formatting import Colorizer
             color = Colorizer(sys.stdout)
             print(color.success(f"✓ mdify is up to date (v{__version__})"))
         return
 
-    from mdify.formatting import Colorizer
     color = Colorizer(sys.stdout)
     print(f"\n{color.bright_yellow('=' * 60)}")
     print(color.bold_yellow("🎉 A new version of mdify-cli is available!"))
@@ -1175,7 +1175,7 @@ def main_async_remote(args) -> int:
             input_path = Path(args.input)
             if not input_path.exists():
                 await ssh_client.disconnect()
-                print(f"Error: Input file or directory not found: {args.input}", file=sys.stderr)
+                print(f"{color.error('✗ Error:')} Input file or directory not found: {args.input}", file=sys.stderr)
                 return 1
             
             # Store resolved path as base for relative path calculations
@@ -1184,8 +1184,8 @@ def main_async_remote(args) -> int:
             
             if not files_to_convert:
                 await ssh_client.disconnect()
-                print(f"Error: No supported files found in {args.input}", file=sys.stderr)
-                print(f"  Supported formats: {', '.join(sorted(SUPPORTED_EXTENSIONS))}", file=sys.stderr)
+                print(f"{color.error('✗ Error:')} No supported files found in {args.input}", file=sys.stderr)
+                print(f"  {color.dim_white(f'Supported formats: {', '.join(sorted(SUPPORTED_EXTENSIONS))}')} ", file=sys.stderr)
                 return 1
             
             if not args.quiet:
@@ -1266,7 +1266,7 @@ def main_async_remote(args) -> int:
                         )
                     
                     attempt = 0
-                    while True:
+                    while attempt <= 1:  # Max 2 attempts (0 and 1)
                         try:
                             # Upload file
                             remote_file_path = f"{work_dir}/{input_file.name}"
@@ -1320,7 +1320,7 @@ def main_async_remote(args) -> int:
                                 f"curl -X POST "
                                 f"--connect-timeout 60 "
                                 f"--max-time {remote_conversion_timeout} "
-                                f"-F 'files=@{remote_file_path}' "
+                                f"-F 'files=@{shlex.quote(remote_file_path)}' "
                                 f"-F 'to_formats=md' "
                                 f"-F 'do_ocr=true' "
                             )
@@ -1333,11 +1333,12 @@ def main_async_remote(args) -> int:
                             conversion_success = False
                             conversion_output = None
                             while conversion_attempt < 3 and not conversion_success:
+                                conversion_attempt += 1
                                 try:
-                                    if conversion_attempt > 0 and not args.quiet:
-                                        # Exponential backoff: 2s, 4s, 8s
-                                        backoff_delay = 2 ** conversion_attempt
-                                        print(f"  ↻ Conversion retry {conversion_attempt} (waiting {backoff_delay}s for server recovery)...", file=sys.stderr)
+                                    if conversion_attempt > 1 and not args.quiet:
+                                        # Exponential backoff: 2s, 4s
+                                        backoff_delay = 2 ** (conversion_attempt - 1)
+                                        print(f"  ↻ Conversion retry {conversion_attempt - 1} (waiting {backoff_delay}s for server recovery)...", file=sys.stderr)
                                         await asyncio.sleep(backoff_delay)
                                     
                                     conversion_output, _, conv_code = await ssh_client.run_command(convert_cmd, timeout=remote_conversion_timeout)
@@ -1350,8 +1351,7 @@ def main_async_remote(args) -> int:
                                         break
                                 except Exception as conv_exc:
                                     is_conn_err = is_connection_error(conv_exc)
-                                    if is_conn_err and conversion_attempt < 2:
-                                        conversion_attempt += 1
+                                    if is_conn_err and conversion_attempt < 3:
                                         if not args.quiet:
                                             # Exponential backoff: 5s, 10s
                                             backoff_delay = 5 * conversion_attempt
@@ -1362,6 +1362,7 @@ def main_async_remote(args) -> int:
                                         try:
                                             await ssh_client.disconnect()
                                         except Exception:
+                                            # Best-effort disconnect; ignore errors (e.g., already closed) before reconnecting
                                             pass
                                         
                                         # Reconnect with retry
@@ -1373,50 +1374,65 @@ def main_async_remote(args) -> int:
                                             continue
                                     else:
                                         # Either not a connection error, or we've exhausted retries
-                                        if not args.quiet:
-                                            print(f"  [DEBUG] Breaking loop: not conn_err or exhausted retries", file=sys.stderr)
-                                        if conversion_attempt >= 2 and is_conn_err:
+                                        if conversion_attempt >= 3 and is_conn_err:
                                             if not args.quiet:
                                                 print(f"  ↻ Connection error on final retry attempt", file=sys.stderr)
                                         break
                             
                             if not conversion_success:
-                                print(f"  ✗ Failed: Conversion failed after {conversion_attempt} attempt(s)", file=sys.stderr)
+                                print(f"  {color.error('✗ Failed:')} Conversion failed after {conversion_attempt} attempt(s)", file=sys.stderr)
                                 failed += 1
                                 break
                             
                             # Parse JSON response to extract markdown content
                             try:
                                 response_data = json.loads(conversion_output)
+                                color_err = Colorizer(sys.stderr)
+                                
+                                # Check if response is an error (has error keys)
+                                error_keys = {"detail", "error", "message", "code", "status"}
+                                response_keys = set(response_data.keys()) if isinstance(response_data, dict) else set()
+                                if error_keys & response_keys:
+                                    # Error response - extract and display error
+                                    error_detail = response_data.get("detail", response_data.get("error", str(response_data)))
+                                    print(f"  {color_err.error('✗ Failed:')} {error_detail}", file=sys.stderr)
+                                    if "DOCLING_SERVE_MAX_SYNC_WAIT" in str(error_detail):
+                                        timeout_val = args.remote_timeout or 3600
+                                        print(f"  {color_err.info('ℹ Tip:')} Increase timeout with --remote-timeout (current: {timeout_val}s)", file=sys.stderr)
+                                    failed += 1
+                                    break
                                 
                                 # Extract content from response structure
                                 # Actual format: {"document": {"md_content": "..."}, "status": "success"}
+                                markdown_content = None
                                 if "document" in response_data:
                                     document = response_data["document"]
                                     if "md_content" in document and document["md_content"]:
                                         markdown_content = document["md_content"]
                                     elif "text_content" in document and document["text_content"]:
                                         markdown_content = document["text_content"]
-                                    else:
-                                        # Fallback - use whole document
-                                        markdown_content = json.dumps(document, indent=2)
-                                else:
+                                elif "results" in response_data and response_data["results"]:
                                     # Legacy format fallback
-                                    if "results" in response_data and response_data["results"]:
-                                        result = response_data["results"][0]
-                                        if "content" in result:
-                                            content = result["content"]
-                                            if isinstance(content, dict) and "markdown" in content:
-                                                markdown_content = content["markdown"]
-                                            elif isinstance(content, str):
-                                                markdown_content = content
-                                            else:
-                                                markdown_content = str(content)
+                                    result = response_data["results"][0]
+                                    if "content" in result:
+                                        content = result["content"]
+                                        if isinstance(content, dict) and "markdown" in content:
+                                            markdown_content = content["markdown"]
+                                        elif isinstance(content, str):
+                                            markdown_content = content
                                         else:
-                                            markdown_content = str(result)
-                                    else:
-                                        # Ultimate fallback
-                                        markdown_content = conversion_output
+                                            markdown_content = str(content)
+                                
+                                # Validate content exists and is not empty/too short
+                                if not markdown_content or len(markdown_content.strip()) < 50:
+                                    print(f"  {color_err.error('✗ Failed:')} Empty or invalid conversion result", file=sys.stderr)
+                                    if args.remote_timeout and args.remote_timeout < 300:
+                                        print(
+                                            f"  {color_err.info('ℹ Tip:')} Timeout is only {args.remote_timeout}s. Consider increasing with --remote-timeout (default: 3600s)",
+                                            file=sys.stderr,
+                                        )
+                                    failed += 1
+                                    break
                                 
                                 # Write markdown content to local temp file first, then upload via SFTP
                                 # (Piping large content through SSH here-documents can crash the connection)
@@ -1424,6 +1440,7 @@ def main_async_remote(args) -> int:
                                 if not args.quiet:
                                     print(f"  {color.cyan('Writing')} {content_size_kb:.1f}KB markdown via SFTP...", file=sys.stderr)
                                 
+                                temp_path = None
                                 try:
                                     # Write to temporary local file
                                     with tempfile.NamedTemporaryFile(mode='w', suffix='.md', delete=False) as temp_file:
@@ -1438,12 +1455,6 @@ def main_async_remote(args) -> int:
                                         compress=False,
                                     )
                                     
-                                    # Cleanup temp file
-                                    try:
-                                        os.unlink(temp_path)
-                                    except Exception:
-                                        pass
-                                    
                                     if not args.quiet:
                                         print(f"  {color.green('✓')} Markdown written", file=sys.stderr)
                                 except Exception as write_exc:
@@ -1451,6 +1462,14 @@ def main_async_remote(args) -> int:
                                         print(f"  ✗ Failed to write markdown: {write_exc}", file=sys.stderr)
                                     failed += 1
                                     break
+                                finally:
+                                    # Cleanup temp file
+                                    if temp_path:
+                                        try:
+                                            os.unlink(temp_path)
+                                        except Exception as cleanup_exc:
+                                            if DEBUG:
+                                                print(f"  ! Failed to remove temporary file {temp_path}: {cleanup_exc}", file=sys.stderr)
                                 
                             except (json.JSONDecodeError, KeyError, IndexError):
                                 print(f"  ✗ Failed to parse conversion response", file=sys.stderr)
@@ -1478,7 +1497,7 @@ def main_async_remote(args) -> int:
                             successful += 1
                             
                             # Cleanup remote files
-                            await ssh_client.run_command(f"rm -f {remote_file_path} {remote_output_path}")
+                            await ssh_client.run_command(f"rm -f {shlex.quote(remote_file_path)} {shlex.quote(remote_output_path)}")
                             
                             break
                         except Exception as e:
@@ -1489,11 +1508,12 @@ def main_async_remote(args) -> int:
                                 try:
                                     await ssh_client.disconnect()
                                 except Exception:
+                                    # Best-effort disconnect; ignore errors since we'll immediately reconnect.
                                     pass
                                 await ssh_client.connect()
                                 continue
                             
-                            print(f"  ✗ Failed: {e}", file=sys.stderr)
+                            print(f"  {color.error('✗ Failed:')} {str(e)}", file=sys.stderr)
                             if DEBUG:
                                 import traceback
                                 traceback.print_exc(file=sys.stderr)
@@ -1515,7 +1535,7 @@ def main_async_remote(args) -> int:
                 
                 # Cleanup remote work directory
                 try:
-                    await ssh_client.run_command(f"rm -rf {work_dir}")
+                    await ssh_client.run_command(f"rm -rf {shlex.quote(work_dir)}")
                     if not args.quiet:
                         print(color.green(f"✓ Cleaned up remote directory"), file=sys.stderr)
                 except Exception as e:
@@ -1590,8 +1610,11 @@ def main_async_remote(args) -> int:
 def main() -> int:
     """Main entry point for the CLI."""
     from mdify.formatting import Colorizer
-    color = Colorizer(sys.stderr)
-    print(color.bold_cyan(f"📄 mdify v{__version__}"), file=sys.stderr)
+    
+    color_stderr = Colorizer(sys.stderr)
+    color_stdout = Colorizer(sys.stdout)
+    
+    print(color_stderr.bold_cyan(f"📄 mdify v{__version__}"), file=sys.stderr)
     args = parse_args()
 
     # Handle --check-update flag
@@ -1739,38 +1762,34 @@ def main() -> int:
 
     # Validate input
     if not input_path.exists():
-        print(f"Error: Input path does not exist: {input_path}", file=sys.stderr)
+        print(f"{color_stderr.error('✗ Error:')} Input path does not exist: {input_path}", file=sys.stderr)
         return 1
 
     # Get files to convert
     try:
         files_to_convert = get_files_to_convert(input_path, args.glob, args.recursive)
     except Exception as e:
-        print(f"Error: {e}", file=sys.stderr)
+        print(f"{color_stderr.error('✗ Error:')} {e}", file=sys.stderr)
         return 1
 
     if not files_to_convert:
-        print(f"No files found to convert in: {input_path}", file=sys.stderr)
+        print(f"{color_stderr.warning('⚠ Warning:')} No files found to convert in: {input_path}", file=sys.stderr)
         return 1
 
     total_files = len(files_to_convert)
     total_size = sum(f.stat().st_size for f in files_to_convert)
 
     if not args.quiet:
-        from mdify.formatting import Colorizer
-        color_info = Colorizer(sys.stdout)
-        print(f"{color_info.bright_cyan('📦 Found')} {color_info.bold(str(total_files))} {color_info.bright_cyan('file(s)')} {color_info.dim_white(f'({format_size(total_size)})')}")
-        print(f"{color_info.cyan('📁 Source:')} {color_info.bright_white(str(input_path.resolve()))}")
-        print(f"{color_info.cyan('💾 Output:')} {color_info.bright_white(str(output_dir.resolve()))}")
-        print(f"{color_info.cyan('🐳 Runtime:')} {color_info.bright_white(runtime)}")
-        print(f"{color_info.cyan('🖼️  Image:')} {color_info.dim_white(image)}")
+        print(f"{color_stdout.bright_cyan('📦 Found')} {color_stdout.bold(str(total_files))} {color_stdout.bright_cyan('file(s)')} {color_stdout.dim_white(f'({format_size(total_size)})')}")
+        print(f"{color_stdout.cyan('📁 Source:')} {color_stdout.bright_white(str(input_path.resolve()))}")
+        print(f"{color_stdout.cyan('💾 Output:')} {color_stdout.bright_white(str(output_dir.resolve()))}")
+        print(f"{color_stdout.cyan('🐳 Runtime:')} {color_stdout.bright_white(runtime)}")
+        print(f"{color_stdout.cyan('🖼️  Image:')} {color_stdout.dim_white(image)}")
         print()
 
     if args.mask:
-        from mdify.formatting import Colorizer
-        color_warn = Colorizer(sys.stderr)
         print(
-            color_warn.warning("⚠ --mask is not supported with docling-serve and will be ignored"),
+            color_stderr.warning("⚠ --mask is not supported with docling-serve and will be ignored"),
             file=sys.stderr,
         )
 
@@ -1787,9 +1806,7 @@ def main() -> int:
 
     try:
         if not args.quiet:
-            from mdify.formatting import Colorizer
-            color_start = Colorizer(sys.stdout)
-            print(f"{color_start.bright_cyan('▶️  Starting')} {color_start.bright_white('docling-serve')} {color_start.bright_cyan('container')}...\n")
+            print(f"{color_stdout.bright_cyan('▶️  Starting')} {color_stdout.bright_white('docling-serve')} {color_stdout.bright_cyan('container')}...\n")
 
         # Apply resource profile
         profile = RESOURCE_PROFILES[args.profile]
@@ -1864,13 +1881,33 @@ def main() -> int:
                         spinner.stop()
 
                     if result.success:
-                        # Write result to output file
-                        output_file.write_text(result.content)
-                        success_count += 1
-                        if not args.quiet:
-                            print(
-                                f"{progress} {input_file.name} ✓ ({format_duration(elapsed)})"
-                            )
+                        # Validate content is not empty and not an error response
+                        content_length = len(result.content.strip()) if result.content else 0
+                        if content_length < 50:
+                            # Too short - likely an error or empty document
+                            failed_count += 1
+                            if not args.quiet:
+                                print(
+                                    f"{progress} {input_file.name} ✗ ({format_duration(elapsed)})"
+                                )
+                                error_msg = "Empty or invalid conversion result"
+                                if result.content:
+                                    error_msg += f" ({len(result.content)} bytes)"
+                                print(f"    Error: {error_msg}", file=sys.stderr)
+                                if args.timeout and args.timeout < 300:
+                                    color_out = Colorizer(sys.stderr)
+                                    print(
+                                        f"    {color_out.info('ℹ Tip:')} Timeout is only {args.timeout}s. Consider increasing with --timeout (default: 1200s)",
+                                        file=sys.stderr,
+                                    )
+                        else:
+                            # Write result to output file
+                            output_file.write_text(result.content)
+                            success_count += 1
+                            if not args.quiet:
+                                print(
+                                    f"{progress} {input_file.name} ✓ ({format_duration(elapsed)})"
+                                )
                     else:
                         failed_count += 1
                         error_msg = result.error or "Unknown error"
@@ -2028,30 +2065,26 @@ def main() -> int:
 
         # Print summary
         if not args.quiet:
-            from mdify.formatting import Colorizer
-            color_out = Colorizer(sys.stdout)
             print()
-            print(color_out.cyan("=" * 60))
-            print(color_out.bold_cyan("📊 Local Conversion Summary"))
-            print(color_out.cyan("=" * 60))
-            print(f"  {color_out.cyan('Total files:')} {color_out.bold(str(total_files))}")
+            print(color_stdout.cyan("=" * 60))
+            print(color_stdout.bold_cyan("📊 Local Conversion Summary"))
+            print(color_stdout.cyan("=" * 60))
+            print(f"  {color_stdout.cyan('Total files:')} {color_stdout.bold(str(total_files))}")
             if success_count > 0:
-                print(f"  {color_out.green('✓ Successful:')} {color_out.bold_green(str(success_count))}")
+                print(f"  {color_stdout.green('✓ Successful:')} {color_stdout.bold_green(str(success_count))}")
             if skipped_count > 0:
-                print(f"  {color_out.yellow('⊘ Skipped:')} {color_out.bold_yellow(str(skipped_count))}")
+                print(f"  {color_stdout.yellow('⊘ Skipped:')} {color_stdout.bold_yellow(str(skipped_count))}")
             if failed_count > 0:
-                print(f"  {color_out.red('✗ Failed:')} {color_out.bold_red(str(failed_count))}")
-            print(f"  {color_out.cyan('Total time:')} {color_out.bright_cyan(format_duration(total_elapsed))}")
-            print(color_out.cyan("=" * 60))
+                print(f"  {color_stdout.red('✗ Failed:')} {color_stdout.bold_red(str(failed_count))}")
+            print(f"  {color_stdout.cyan('Total time:')} {color_stdout.bright_cyan(format_duration(total_elapsed))}")
+            print(color_stdout.cyan("=" * 60))
 
     except KeyboardInterrupt:
         if not args.quiet:
-            from mdify.formatting import Colorizer
-            color_out = Colorizer(sys.stdout)
-            print(f"\n\n{color_out.warning('⚠ Interrupted by user. Container stopped.')}")
+            print(f"\n\n{color_stdout.warning('⚠ Interrupted by user. Container stopped.')}")
             if success_count > 0 or skipped_count > 0 or failed_count > 0:
                 print(
-                    f"{color_out.dim_white('Partial progress:')} {color_out.green(str(success_count))} successful, {color_out.red(str(failed_count))} failed, {color_out.yellow(str(skipped_count))} skipped"
+                    f"{color_stdout.dim_white('Partial progress:')} {color_stdout.green(str(success_count))} successful, {color_stdout.red(str(failed_count))} failed, {color_stdout.yellow(str(skipped_count))} skipped"
                 )
         return 130
 

{mdify_cli-3.2.0 → mdify_cli-3.3.0}/mdify/docling_client.py

@@ -48,6 +48,25 @@ def _get_mime_type(file_path: Path) -> str:
     return mime_type or "application/octet-stream"
 
 
+def _is_error_response(result_data) -> bool:
+    """Check if response contains an error instead of content.
+    
+    Detects common API error response patterns.
+    
+    Args:
+        result_data: Response data to check
+        
+    Returns:
+        True if response appears to be an error
+    """
+    if not isinstance(result_data, dict):
+        return False
+    
+    # Check for common error keys at top level
+    error_keys = {"detail", "error", "message", "code", "status"}
+    return bool(error_keys & set(result_data.keys()))
+
+
 def _extract_content(result_data) -> str:
     """Extract content from API response, supporting both old and new formats.
 
@@ -61,8 +80,12 @@ def _extract_content(result_data) -> str:
         result_data: Response data from docling-serve API
 
     Returns:
-        Extracted content string, or empty string if not found
+        Extracted content string, or empty string if not found or if response is an error
     """
+    # Detect error responses and return empty string instead of parsing them
+    if _is_error_response(result_data):
+        return ""
+    
     if isinstance(result_data, dict):
         # New format with document field
         if "document" in result_data:

{mdify_cli-3.2.0 → mdify_cli-3.3.0}/mdify/ssh/models.py

@@ -66,18 +66,6 @@ class SSHConfig:
     
     def __post_init__(self):
         """Validate config after initialization."""
-        if self.port is None:
-            self.port = 22
-        if self.timeout is None:
-            self.timeout = 30
-        if self.keepalive is None:
-            self.keepalive = 60
-        if self.compression is None:
-            self.compression = False
-        if self.work_dir is None:
-            self.work_dir = "/tmp/mdify"
-        if self.username is None:
-            self.username = ""
         if not self.host:
             raise ConfigError("host is required")
         if not 1 <= self.port <= 65535:

{mdify_cli-3.2.0 → mdify_cli-3.3.0}/mdify/ssh/remote_container.py

@@ -63,7 +63,7 @@ class RemoteContainer(DoclingContainer):
         try:
             # Find containers using this port
             # Using docker inspect with port filter
-            cmd = f"{self.runtime} ps -a --filter 'publish={self.port}' --format '{{{{.ID}}}}'"
+            cmd = f"{self.runtime} ps -a --filter 'publish={int(self.port)}' --format '{{{{.ID}}}}'"
             stdout, stderr, code = await self.ssh_client.run_command(cmd, timeout=10)
             
             if code == 0 and stdout.strip():

{mdify_cli-3.2.0 → mdify_cli-3.3.0}/mdify/ssh/transfer.py

@@ -3,6 +3,7 @@
 import gzip
 import hashlib
 import logging
+import shlex
 from pathlib import Path
 from typing import Callable
 from mdify.ssh.models import TransferSession
@@ -233,8 +234,8 @@ class FileTransferManager:
         
         # Calculate remote checksum (sha256sum or shasum fallback)
         checksum_cmd = (
-            f"(command -v sha256sum >/dev/null 2>&1 && sha256sum {remote_path} | awk '{{print $1}}') "
-            f"|| (command -v shasum >/dev/null 2>&1 && shasum -a 256 {remote_path} | awk '{{print $1}}')"
+            f"(command -v sha256sum >/dev/null 2>&1 && sha256sum {shlex.quote(remote_path)} | awk '{{print $1}}') "
+            f"|| (command -v shasum >/dev/null 2>&1 && shasum -a 256 {shlex.quote(remote_path)} | awk '{{print $1}}')"
         )
         stdout, stderr, code = await self.ssh_client.run_command(checksum_cmd)
         

{mdify_cli-3.2.0 → mdify_cli-3.3.0}/mdify_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mdify-cli
-Version: 3.2.0
+Version: 3.3.0
 Summary: Convert PDFs and document images into structured Markdown for LLM workflows
 Author: tiroq
 License-Expression: MIT

{mdify_cli-3.2.0 → mdify_cli-3.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "mdify-cli"
-version = "3.2.0"
+version = "3.3.0"
 description = "Convert PDFs and document images into structured Markdown for LLM workflows"
 readme = "README.md"
 requires-python = ">=3.10"