feat: add r1fs delete file endpoint (#289)

* feat: add r1fs delete file endpoint

* fix: r1fs API logging

* chore: inc version

Author: toderian

extensions/business/r1fs/r1fs_manager_api.py

@@ -39,12 +39,61 @@ def on_init(self):
   def _log_request_response(self, endpoint_name: str, request_data: dict = None, response_data: dict = None):
     """Helper method to log requests and responses when verbose mode is enabled"""
     if hasattr(self, 'cfg_r1fs_verbose') and self.cfg_r1fs_verbose > 10:
-      if request_data:
-        self.P(f"=== {endpoint_name} ENDPOINT ===", color='y')
-        self.P(f"REQUEST: {self.json.dumps(request_data, indent=2)}", color='c')
-      if response_data:
-        self.P(f"RESPONSE: {self.json.dumps(response_data, indent=2)}", color='g')
-        self.P(f"=== END {endpoint_name} ===", color='y')
+      if request_data is not None:
+        sanitized_request = self._sanitize_payload(request_data)
+        self.P(f"[{endpoint_name}] request: {self.json.dumps(sanitized_request)}", color='c')
+      if response_data is not None:
+        sanitized_response = self._sanitize_payload(response_data)
+        self.P(f"[{endpoint_name}] response: {self.json.dumps(sanitized_response)}", color='g')
+
+  def _sanitize_payload(self, payload, max_length: int = 64, depth: int = 0, key_path: str = ""):
+    """
+    Sanitize payloads before logging to avoid leaking secrets or large contents.
+    """
+    sensitive_tokens = (
+      "secret", "key", "token", "pass", "pwd", "credential", "auth",
+      "signature", "base64", "content", "body", "payload", "data", "yaml",
+      "json", "pickle"
+    )
+
+    if payload is None:
+      return None
+
+    if depth >= 3:
+      return "[truncated]"
+
+    if isinstance(payload, dict):
+      sanitized = {}
+      for key, value in payload.items():
+        child_path = f"{key_path}.{key}" if key_path else str(key)
+        sanitized[key] = self._sanitize_payload(value, max_length, depth + 1, child_path)
+      return sanitized
+
+    if isinstance(payload, (list, tuple, set)):
+      sanitized_iterable = [
+        self._sanitize_payload(value, max_length, depth + 1, f"{key_path}.{idx}")
+        for idx, value in enumerate(payload)
+      ]
+      return sanitized_iterable
+
+    if isinstance(payload, bytes):
+      return f"[bytes len={len(payload)}]"
+
+    if isinstance(payload, str):
+      lower_path = key_path.lower()
+      if any(token in lower_path for token in sensitive_tokens):
+        return "***"
+      if len(payload) > max_length:
+        return f"{payload[:max_length]}... (len={len(payload)})"
+      return payload
+
+    if isinstance(payload, (int, float, bool)):
+      return payload
+
+    if any(token in key_path.lower() for token in sensitive_tokens):
+      return "***"
+
+    return f"[{payload.__class__.__name__}]"
 
 
   @BasePlugin.endpoint(method="get", require_token=False)
@@ -93,11 +142,12 @@ def add_file(self, file_path: str, body_json: any = None, secret: str = None, no
     }
     self._log_request_response("ADD_FILE", request_data=request_data)
 
-    self.P(f"Starting add_file with uploaded file at: {file_path}")
-    self.P(f"Body: {self.json.dumps(body_json, indent=2)}")
-
+    self.P(f"Starting add_file for {file_path}")
+    body_json = body_json or {}
+    if not isinstance(body_json, dict):
+      body_json = {}
     secret = body_json.get('secret', None)
-    self.P(f"Extracted secret: {secret}")
+    self.P(f"Secret provided: {'yes' if secret else 'no'}")
 
     cid = self.r1fs.add_file(file_path=file_path, secret=secret, nonce=nonce)
 
@@ -139,7 +189,7 @@ def get_file(self, cid: str, secret: str = None):
     }
     self._log_request_response("GET_FILE", request_data=request_data)
 
-    self.P(f"Retrieving file with CID='{cid}', secret='{secret}'...")
+    self.P(f"Retrieving file with CID='{cid}', secret_provided={'yes' if secret else 'no'}")
 
     fn = self.r1fs.get_file(cid=cid, secret=secret)
 
@@ -161,7 +211,7 @@ def get_file(self, cid: str, secret: str = None):
       'meta': meta
     }
 
-    self.P(f"response: {self.json.dumps(response, indent=2)}")
+    self.P(f"GET_FILE completed, file_path set: {bool(fn)}")
 
     # Log response
     self._log_request_response("GET_FILE", response_data=response)
@@ -196,7 +246,7 @@ def add_file_base64(self, file_base64_str: str, filename: str = None, secret: st
     }
     self._log_request_response("ADD_FILE_BASE64", request_data=request_data)
 
-    self.P(f"New base64 File={file_base64_str}")
+    self.P(f"Received base64 payload length={len(file_base64_str) if file_base64_str else 0}")
     if not filename:
       filename = self.r1fs._get_unique_or_complete_upload_name()
 
@@ -254,7 +304,7 @@ def get_file_base64(self, cid: str, secret: str = None):  # first parameter must
     filename = file.split('/')[-1] if file else None
     self.P(f"File retrieved: {file}")
     file_base64 = self.diskapi_load_r1fs_file(file, verbose=True, to_base64=True)
-    self.P("file retrieved: {}".format(file_base64))
+    self.P(f"Encoded payload length={len(file_base64) if file_base64 else 0}")
 
     data = {
       "file_base64_str": file_base64,
@@ -299,7 +349,8 @@ def add_yaml(self, data: dict, fn: str = None, secret: str = None, nonce: int =
     }
     self._log_request_response("ADD_YAML", request_data=request_data)
 
-    self.P(f"Adding data={data} to yaml, secret='{secret}'", color='g')
+    yaml_keys = list(data.keys()) if isinstance(data, dict) else type(data).__name__
+    self.P(f"Adding YAML payload with keys={yaml_keys}, secret_provided={'yes' if secret else 'no'}", color='g')
 
     cid = self.r1fs.add_yaml(data=data, fn=fn, secret=secret)
     self.P(f"Cid='{cid}'")
@@ -335,14 +386,14 @@ def get_yaml(self, cid: str, secret: str = None):
     # Log request
     request_data = {
       'cid': cid,
-      'secret': secret
+      'secret': "***" if secret else None,
     }
     self._log_request_response("GET_YAML", request_data=request_data)
 
-    self.P(f"Retrieving file with CID='{cid}', secret='{secret}'...")
+    self.P(f"Retrieving YAML with CID='{cid}', secret_provided={'yes' if secret else 'no'}")
 
     fn = self.r1fs.get_file(cid=cid, secret=secret)
-    self.P(f"fn: {fn}")
+    self.P(f"Retrieved file path: {fn}")
 
     if fn is None:
       error_msg = f"Failed to retrieve file with CID '{cid}'. The file may not exist or the IPFS download failed."
@@ -352,7 +403,8 @@ def get_yaml(self, cid: str, secret: str = None):
 
     if fn.endswith('.yaml') or fn.endswith('.yml'):
       file_data = self.diskapi_load_yaml(fn, verbose=False)
-      self.P(f"File found: {file_data}")
+      summary = list(file_data.keys()) if isinstance(file_data, dict) else type(file_data).__name__
+      self.P(f"Parsed YAML payload summary: {summary}")
 
     else:
       self.P(f"Error retrieving file: {fn}")
@@ -365,7 +417,11 @@ def get_yaml(self, cid: str, secret: str = None):
     }
 
     # Log response
-    self._log_request_response("GET_YAML", response_data=data)
+    response_summary = {
+      'file_data_type': type(file_data).__name__,
+      'file_data_keys': list(file_data.keys()) if isinstance(file_data, dict) else None
+    }
+    self._log_request_response("GET_YAML", response_data=response_summary)
 
     return data
 
@@ -534,5 +590,125 @@ def calculate_pickle_cid(self, data: object, nonce: int, fn: str = None, secret:
 
     return data
 
+
+  @BasePlugin.endpoint(method="post", require_token=False)
+  def delete_file(
+    self,
+    cid: str,
+    unpin_remote: bool = True,
+    run_gc: bool = False,
+    cleanup_local_files: bool = False
+  ):
+    """
+    Delete a file from R1FS by unpinning it locally and optionally on the relay.
+
+    This endpoint removes a file from the decentralized file system by unpinning it.
+    The file is marked for garbage collection and will be removed when GC runs.
+
+    Args:
+        cid (str): Content Identifier of the file to delete
+        unpin_remote (bool, optional): Whether to also unpin from the relay. Default is True
+        run_gc (bool, optional): Whether to run garbage collection immediately. Default is False
+        cleanup_local_files (bool, optional): Whether to remove local downloaded files. Default is False
+
+    Returns:
+        dict: Response containing success status and message:
+            - success: Boolean indicating if deletion was successful
+            - message: Status message
+            - cid: The CID that was deleted
+    """
+    # Log request
+    request_data = {
+      'cid': cid,
+      'unpin_remote': unpin_remote,
+      'run_gc': run_gc,
+      'cleanup_local_files': cleanup_local_files
+    }
+    self._log_request_response("DELETE_FILE", request_data=request_data)
+
+    self.P(f"Deleting file with CID='{cid}', unpin_remote={unpin_remote}, run_gc={run_gc}")
+
+    success = self.r1fs.delete_file(
+      cid=cid,
+      unpin_remote=unpin_remote,
+      run_gc=run_gc,
+      cleanup_local_files=cleanup_local_files,
+      show_logs=True,
+      raise_on_error=False
+    )
+
+    if success:
+      message = f"File {cid} deleted successfully"
+      self.P(message, color='g')
+    else:
+      message = f"Failed to delete file {cid}"
+      self.P(message, color='r')
+
+    response = {
+      "success": success,
+      "message": message,
+      "cid": cid
+    }
+
+    # Log response
+    self._log_request_response("DELETE_FILE", response_data=response)
+
+    return response
+
+
+  @BasePlugin.endpoint(method="post", require_token=False)
+  def delete_files(
+    self,
+    cids: list,
+    unpin_remote: bool = True,
+    run_gc_after_all: bool = True,
+    cleanup_local_files: bool = False
+  ):
+    """
+    Delete multiple files from R1FS in bulk.
+
+    This endpoint removes multiple files from the decentralized file system by
+    unpinning them. More efficient than calling delete_file repeatedly as it
+    can run garbage collection once at the end.
+
+    Args:
+        cids (list): List of Content Identifiers to delete
+        unpin_remote (bool, optional): Whether to also unpin from the relay. Default is True
+        run_gc_after_all (bool, optional): Whether to run GC once after all deletions. Default is True
+        cleanup_local_files (bool, optional): Whether to remove local downloaded files. Default is False
+
+    Returns:
+        dict: Response containing deletion results:
+            - success: List of successfully deleted CIDs
+            - failed: List of CIDs that failed to delete
+            - total: Total number of CIDs processed
+            - success_count: Number of successful deletions
+            - failed_count: Number of failed deletions
+    """
+    # Log request
+    request_data = {
+      'cids': cids,
+      'unpin_remote': unpin_remote,
+      'run_gc_after_all': run_gc_after_all,
+      'cleanup_local_files': cleanup_local_files
+    }
+    self._log_request_response("DELETE_FILES", request_data=request_data)
+
+    self.P(f"Bulk deleting {len(cids)} files, unpin_remote={unpin_remote}, run_gc_after_all={run_gc_after_all}")
+
+    result = self.r1fs.delete_files(
+      cids=cids,
+      unpin_remote=unpin_remote,
+      run_gc_after_all=run_gc_after_all,
+      cleanup_local_files=cleanup_local_files,
+      show_logs=True,
+      raise_on_error=False
+    )
+
+    # Log response
+    self._log_request_response("DELETE_FILES", response_data=result)
+
+    return result
+
 #########################################################################
 #########################################################################

ver.py

@@ -1 +1 @@
-__VER__ = '2.9.823'
+__VER__ = '2.9.824'