@nomad-e/bluma-cli 0.1.17 → 0.1.19

package/dist/config/skills/xlsx/scripts/office/soffice.py

@@ -0,0 +1,180 @@
+"""
+LibreOffice process management for sandboxed and standard environments.
+
+Handles:
+- Finding the soffice binary across platforms
+- Running recalculation macros in headless mode
+- Configuring Unix sockets for restricted environments
+"""
+
+import os
+import platform
+import shutil
+import subprocess
+import tempfile
+
+
+SOFFICE_SEARCH_PATHS = [
+    '/usr/bin/soffice',
+    '/usr/bin/libreoffice',
+    '/usr/lib/libreoffice/program/soffice',
+    '/snap/bin/libreoffice',
+    '/opt/libreoffice/program/soffice',
+]
+
+MACOS_PATHS = [
+    '/Applications/LibreOffice.app/Contents/MacOS/soffice',
+    os.path.expanduser('~/Applications/LibreOffice.app/Contents/MacOS/soffice'),
+]
+
+
+def find_soffice() -> str | None:
+    """Find the soffice binary on this system."""
+    found = shutil.which('soffice') or shutil.which('libreoffice')
+    if found:
+        return found
+
+    search = MACOS_PATHS if platform.system() == 'Darwin' else SOFFICE_SEARCH_PATHS
+
+    for path in search:
+        if os.path.isfile(path) and os.access(path, os.X_OK):
+            return path
+
+    return None
+
+
+def _prepare_user_profile(base_dir: str) -> str:
+    """Create a temporary user profile to avoid lock conflicts."""
+    profile_dir = os.path.join(base_dir, 'libreoffice-profile')
+    os.makedirs(profile_dir, exist_ok=True)
+    return profile_dir
+
+
+def _build_macro_content(filepath: str) -> str:
+    """Build a LibreOffice Basic macro that recalculates all sheets."""
+    abs_path = os.path.abspath(filepath)
+    url = 'file://' + abs_path.replace(' ', '%20')
+
+    return f"""
+Sub RecalcAndSave
+    Dim oDoc As Object
+    Dim oSheets As Object
+    Dim oSheet As Object
+    Dim i As Integer
+
+    oDoc = StarDesktop.loadComponentFromURL( _
+        "{url}", "_blank", 0, _
+        Array(MakePropertyValue("Hidden", True), _
+              MakePropertyValue("MacroExecutionMode", 4)))
+
+    If IsNull(oDoc) Or IsEmpty(oDoc) Then
+        MsgBox "Failed to open document"
+        Exit Sub
+    End If
+
+    oSheets = oDoc.getSheets()
+    For i = 0 To oSheets.getCount() - 1
+        oSheet = oSheets.getByIndex(i)
+    Next i
+
+    oDoc.calculateAll()
+    oDoc.calculateAll()
+
+    oDoc.store()
+    oDoc.close(True)
+End Sub
+
+Function MakePropertyValue(sName As String, vValue As Variant) As com.sun.star.beans.PropertyValue
+    Dim oProperty As New com.sun.star.beans.PropertyValue
+    oProperty.Name = sName
+    oProperty.Value = vValue
+    MakePropertyValue = oProperty
+End Function
+"""
+
+
+def run_soffice_recalc(
+    soffice_path: str,
+    filepath: str,
+    timeout: int = 60,
+) -> tuple[bool, str]:
+    """
+    Recalculate an Excel file using LibreOffice headless mode.
+
+    Returns (success: bool, message: str).
+    """
+    abs_path = os.path.abspath(filepath)
+
+    if not os.path.isfile(abs_path):
+        return False, f'File not found: {abs_path}'
+
+    with tempfile.TemporaryDirectory(prefix='bluma-lo-') as tmp_dir:
+        profile_dir = _prepare_user_profile(tmp_dir)
+
+        macro_content = _build_macro_content(abs_path)
+        macro_dir = os.path.join(
+            profile_dir, 'user', 'basic', 'Standard'
+        )
+        os.makedirs(macro_dir, exist_ok=True)
+
+        macro_file = os.path.join(macro_dir, 'BluMaRecalc.xba')
+        with open(macro_file, 'w') as f:
+            f.write('<?xml version="1.0" encoding="UTF-8"?>\n')
+            f.write('<!DOCTYPE script:module PUBLIC "-//OpenOffice.org//DTD OfficeDocument 1.0//EN" "module.dtd">\n')
+            f.write('<script:module xmlns:script="http://openoffice.org/2000/script" ')
+            f.write('script:name="BluMaRecalc" script:language="StarBasic">\n')
+            f.write(macro_content)
+            f.write('\n</script:module>\n')
+
+        dialog_lc = os.path.join(macro_dir, 'dialog.xlc')
+        with open(dialog_lc, 'w') as f:
+            f.write('<?xml version="1.0" encoding="UTF-8"?>\n')
+            f.write('<!DOCTYPE library:library PUBLIC "-//OpenOffice.org//DTD OfficeDocument 1.0//EN" "library.dtd">\n')
+            f.write('<library:library xmlns:library="http://openoffice.org/2000/library" ')
+            f.write('library:name="Standard" library:readonly="false" library:passwordprotected="false">\n')
+            f.write('</library:library>\n')
+
+        script_lc = os.path.join(macro_dir, 'script.xlc')
+        with open(script_lc, 'w') as f:
+            f.write('<?xml version="1.0" encoding="UTF-8"?>\n')
+            f.write('<!DOCTYPE library:library PUBLIC "-//OpenOffice.org//DTD OfficeDocument 1.0//EN" "library.dtd">\n')
+            f.write('<library:library xmlns:library="http://openoffice.org/2000/library" ')
+            f.write('library:name="Standard" library:readonly="false" library:passwordprotected="false">\n')
+            f.write(f' <library:element library:name="BluMaRecalc"/>\n')
+            f.write('</library:library>\n')
+
+        env = os.environ.copy()
+        env['HOME'] = tmp_dir
+        env['SAL_USE_VCLPLUGIN'] = 'gen'
+
+        cmd = [
+            soffice_path,
+            '--headless',
+            '--invisible',
+            '--nologo',
+            '--norestore',
+            f'-env:UserInstallation=file://{profile_dir}',
+            f'macro:///Standard.BluMaRecalc.RecalcAndSave',
+        ]
+
+        try:
+            proc = subprocess.run(
+                cmd,
+                capture_output=True,
+                text=True,
+                timeout=timeout,
+                env=env,
+            )
+
+            if proc.returncode != 0:
+                stderr = proc.stderr.strip()[:500] if proc.stderr else 'No error output'
+                return False, f'LibreOffice exited with code {proc.returncode}: {stderr}'
+
+            return True, 'Recalculation completed'
+
+        except subprocess.TimeoutExpired:
+            return False, f'LibreOffice timed out after {timeout} seconds'
+        except FileNotFoundError:
+            return False, f'soffice binary not found at: {soffice_path}'
+        except Exception as e:
+            return False, f'Unexpected error: {str(e)}'

package/dist/config/skills/xlsx/scripts/office/unpack.py

@@ -0,0 +1,63 @@
+"""
+Unpack an Office Open XML file (.xlsx/.docx/.pptx) into a directory.
+
+This allows direct manipulation of the internal XML structure, which is
+useful for repairs, validation, or modifications not possible through
+standard libraries.
+"""
+
+import os
+import zipfile
+
+
+def unpack(filepath: str, dest_dir: str | None = None) -> str:
+    """
+    Extract an Office file into a directory.
+
+    Args:
+        filepath: Path to the .xlsx/.docx/.pptx file.
+        dest_dir: Destination directory. If None, creates one next to
+                  the source file with '_unpacked' suffix.
+
+    Returns:
+        Absolute path to the unpacked directory.
+    """
+    abs_path = os.path.abspath(filepath)
+
+    if not os.path.isfile(abs_path):
+        raise FileNotFoundError(f'File not found: {abs_path}')
+
+    if dest_dir is None:
+        base = os.path.splitext(abs_path)[0]
+        dest_dir = base + '_unpacked'
+
+    abs_dest = os.path.abspath(dest_dir)
+    os.makedirs(abs_dest, exist_ok=True)
+
+    try:
+        with zipfile.ZipFile(abs_path, 'r') as zf:
+            zf.extractall(abs_dest)
+    except zipfile.BadZipFile:
+        raise ValueError(f'Not a valid Office/ZIP file: {abs_path}')
+
+    return abs_dest
+
+
+def list_contents(filepath: str) -> list[dict]:
+    """
+    List the internal structure of an Office file.
+
+    Returns a list of dicts with 'name', 'size', and 'compressed_size'.
+    """
+    abs_path = os.path.abspath(filepath)
+
+    with zipfile.ZipFile(abs_path, 'r') as zf:
+        return [
+            {
+                'name': info.filename,
+                'size': info.file_size,
+                'compressed_size': info.compress_size,
+            }
+            for info in zf.infolist()
+            if not info.is_dir()
+        ]

package/dist/config/skills/xlsx/scripts/office/validate.py

@@ -0,0 +1,122 @@
+"""
+Validate the internal structure of Office Open XML files.
+
+Checks that required parts exist, relationships are consistent,
+and the ZIP structure is well-formed. Does NOT validate against
+full ISO/IEC 29500 schemas (that would require lxml + full schema set).
+"""
+
+import os
+import zipfile
+
+REQUIRED_PARTS_XLSX = [
+    '[Content_Types].xml',
+    '_rels/.rels',
+    'xl/workbook.xml',
+    'xl/_rels/workbook.xml.rels',
+    'xl/styles.xml',
+]
+
+REQUIRED_PARTS_DOCX = [
+    '[Content_Types].xml',
+    '_rels/.rels',
+    'word/document.xml',
+    'word/_rels/document.xml.rels',
+    'word/styles.xml',
+]
+
+REQUIRED_PARTS_PPTX = [
+    '[Content_Types].xml',
+    '_rels/.rels',
+    'ppt/presentation.xml',
+    'ppt/_rels/presentation.xml.rels',
+]
+
+FILE_TYPE_MAP = {
+    '.xlsx': ('xlsx', REQUIRED_PARTS_XLSX),
+    '.xlsm': ('xlsx', REQUIRED_PARTS_XLSX),
+    '.docx': ('docx', REQUIRED_PARTS_DOCX),
+    '.pptx': ('pptx', REQUIRED_PARTS_PPTX),
+}
+
+
+def validate(filepath: str) -> dict:
+    """
+    Validate an Office file's internal structure.
+
+    Returns a dict with:
+        - valid (bool): Whether the file passes validation
+        - file_type (str): Detected type (xlsx/docx/pptx)
+        - parts_count (int): Number of parts in the archive
+        - missing_parts (list): Required parts that are missing
+        - warnings (list): Non-critical issues
+        - errors (list): Critical issues
+    """
+    abs_path = os.path.abspath(filepath)
+    ext = os.path.splitext(abs_path)[1].lower()
+
+    result = {
+        'valid': True,
+        'file_type': None,
+        'parts_count': 0,
+        'missing_parts': [],
+        'warnings': [],
+        'errors': [],
+    }
+
+    if not os.path.isfile(abs_path):
+        result['valid'] = False
+        result['errors'].append(f'File not found: {abs_path}')
+        return result
+
+    if ext not in FILE_TYPE_MAP:
+        result['valid'] = False
+        result['errors'].append(f'Unsupported extension: {ext}')
+        return result
+
+    file_type, required_parts = FILE_TYPE_MAP[ext]
+    result['file_type'] = file_type
+
+    try:
+        with zipfile.ZipFile(abs_path, 'r') as zf:
+            names = set(zf.namelist())
+            result['parts_count'] = len(names)
+
+            for part in required_parts:
+                if part not in names:
+                    result['missing_parts'].append(part)
+
+            corrupt = zf.testzip()
+            if corrupt:
+                result['errors'].append(f'Corrupt entry: {corrupt}')
+
+    except zipfile.BadZipFile:
+        result['valid'] = False
+        result['errors'].append('Not a valid ZIP file')
+        return result
+    except Exception as e:
+        result['valid'] = False
+        result['errors'].append(f'Error reading file: {str(e)}')
+        return result
+
+    if result['missing_parts']:
+        result['valid'] = False
+        result['errors'].append(
+            f"Missing {len(result['missing_parts'])} required part(s)"
+        )
+
+    for name in names:
+        if name.startswith('..') or '/../' in name:
+            result['valid'] = False
+            result['errors'].append(f'Path traversal detected: {name}')
+
+    if result['parts_count'] == 0:
+        result['valid'] = False
+        result['errors'].append('Archive is empty')
+
+    if result['parts_count'] > 10000:
+        result['warnings'].append(
+            f'Unusually large archive: {result["parts_count"]} entries'
+        )
+
+    return result

package/dist/config/skills/xlsx/scripts/recalc.py

@@ -0,0 +1,143 @@
+#!/usr/bin/env python3
+"""
+Recalculate all formulas in an Excel file using LibreOffice and scan
+for formula errors.
+
+Usage:
+    python recalc.py <excel_file> [timeout_seconds]
+
+Returns JSON to stdout with recalculation status and any errors found.
+Requires LibreOffice installed and openpyxl for error scanning.
+
+Exit codes:
+    0  Recalculated successfully (may still have formula errors)
+    1  Recalculation failed
+"""
+
+import json
+import os
+import sys
+import time
+
+SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
+sys.path.insert(0, SCRIPT_DIR)
+
+from office.soffice import find_soffice, run_soffice_recalc
+
+
+ERROR_VALUES = frozenset({
+    '#REF!', '#DIV/0!', '#VALUE!', '#N/A', '#NAME?',
+    '#NULL!', '#NUM!', '#GETTING_DATA', '#SPILL!', '#CALC!',
+})
+
+
+def scan_errors_fast(filepath: str) -> dict:
+    """Optimized error scanning — loads formula workbook only once."""
+    try:
+        from openpyxl import load_workbook
+    except ImportError:
+        return {
+            'status': 'error',
+            'message': 'openpyxl not installed — cannot scan for formula errors',
+        }
+
+    wb_data = load_workbook(filepath, data_only=True)
+    wb_formula = load_workbook(filepath)
+
+    errors = {}
+    total_formulas = 0
+    sheets_processed = []
+
+    for sheet_name in wb_data.sheetnames:
+        ws_data = wb_data[sheet_name]
+        ws_form = wb_formula[sheet_name]
+        sheets_processed.append(sheet_name)
+
+        for row_data, row_form in zip(ws_data.iter_rows(), ws_form.iter_rows()):
+            for cell_data, cell_form in zip(row_data, row_form):
+                if isinstance(cell_form.value, str) and cell_form.value.startswith('='):
+                    total_formulas += 1
+
+                if isinstance(cell_data.value, str) and cell_data.value in ERROR_VALUES:
+                    err_type = cell_data.value
+                    if err_type not in errors:
+                        errors[err_type] = {'count': 0, 'locations': []}
+                    errors[err_type]['count'] += 1
+                    loc = f"{sheet_name}!{cell_data.coordinate}"
+                    if len(errors[err_type]['locations']) < 20:
+                        errors[err_type]['locations'].append(loc)
+
+    wb_data.close()
+    wb_formula.close()
+
+    total_errors = sum(e['count'] for e in errors.values())
+
+    result = {
+        'total_formulas': total_formulas,
+        'total_errors': total_errors,
+        'sheets_processed': sheets_processed,
+    }
+
+    if total_errors > 0:
+        result['status'] = 'errors_found'
+        result['error_summary'] = errors
+    else:
+        result['status'] = 'success'
+
+    return result
+
+
+def main():
+    if len(sys.argv) < 2:
+        print(json.dumps({
+            'status': 'error',
+            'message': 'Usage: python recalc.py <excel_file> [timeout_seconds]',
+        }))
+        sys.exit(1)
+
+    filepath = os.path.abspath(sys.argv[1])
+    timeout = int(sys.argv[2]) if len(sys.argv) > 2 else 60
+
+    if not os.path.isfile(filepath):
+        print(json.dumps({
+            'status': 'error',
+            'message': f'File not found: {filepath}',
+        }))
+        sys.exit(1)
+
+    soffice_path = find_soffice()
+    if not soffice_path:
+        print(json.dumps({
+            'status': 'error',
+            'message': (
+                'LibreOffice not found. Install it with: '
+                'sudo apt install libreoffice-calc (Linux) or '
+                'brew install --cask libreoffice (macOS)'
+            ),
+        }))
+        sys.exit(1)
+
+    start = time.time()
+
+    success, message = run_soffice_recalc(soffice_path, filepath, timeout)
+
+    elapsed = round(time.time() - start, 2)
+
+    if not success:
+        print(json.dumps({
+            'status': 'error',
+            'message': message,
+            'elapsed_seconds': elapsed,
+        }))
+        sys.exit(1)
+
+    result = scan_errors_fast(filepath)
+    result['elapsed_seconds'] = elapsed
+    result['recalc_engine'] = 'LibreOffice'
+
+    print(json.dumps(result, indent=2))
+    sys.exit(0)
+
+
+if __name__ == '__main__':
+    main()