Locking Code Sections from AI Edits in Lovable

 
Creating the Lock Configuration File
 

• In the Lovable code editor, create a new file named lock\_config.json. This file will store a flag that determines if certain parts of your code are locked.
• Paste the following code into lock\_config.json:

  
  {
    "locked": true
  }
      

• This flag ("locked") controls whether the locked code segments should execute. To unlock those parts, simply change true to false in this file.

 
Modifying the Main Code to Check the Lock Status
 

• Open your existing main code file where you want to lock parts of the code. For example, if your file is app.py, open it in the Lovable editor.
• At the top of your file, add code to import the JSON module and load the lock configuration. Insert the following snippet at the very beginning of your file:

  
  import json
  
  with open('lock_config.json', 'r') as config_file:
      lock_config = json.load(config_file)
      

  
  


• This code reads the lock_config.json file and stores its content into the variable lock_config.

 
Creating a Decorator to Manage Access to Sensitive Code
 

• In your app.py (or another appropriate file), define a decorator that will check whether a code section is locked. Insert the following code after loading the configuration:

  
  def lock\_guard(func):
      def wrapper(_args, _\*kwargs):
          if lock\_config.get("locked", False):
              print("This section of the code is locked and cannot run.")
              return
          return func(_args, _\*kwargs)
      return wrapper
      

• This decorator (lock\_guard) wraps any function to check the locked flag. When the flag is true, the function will be blocked, and a message will appear.

 
Applying the Decorator to Sensitive Functions
 

• Identify the parts of your code that you want to lock. For each sensitive function, add the @lock\_guard decorator above its definition. For example:

  
  @lock\_guard
  def sensitive\_operation():
      print("Running a critical operation.")
      # Your sensitive code here
  
  Somewhere in your code logic, you might call this function:
  sensitive_operation()
      

  
  


• The decorator ensures that when lock_config.json has "locked": true, the function will not execute, protecting that part of your codebase.

 
Managing the Lock at Runtime Without a Terminal
 

• Since Lovable does not include a terminal, any changes to the lock state must be performed by editing lock\_config.json directly in the code editor.
• To unlock the code sections, simply change the "locked" flag from true to false in lock\_config.json:

  
  {
    "locked": false
  }
      

• Save the file. On the next run of your application, the sensitive functions wrapped with @lock\_guard will execute as normal.

 
Creating a Dedicated File for Locked Code
 

• Create a new file called locked\_code.py. This file will contain the core logic that should not be modified once it is set.
• Inside this file, write your key logic. For example, you can start with a simple function that represents the locked functionality:

  
  def locked\_function():
      # This function contains important logic that is locked.
      return "This is the locked code functionality."
      

• Keep locked\_code.py separate from other parts of your project to make it clear that its contents are not to be edited.

 
Enforcing File Read-Only Status Programmatically
 

• To help prevent accidental changes, you can change the file permission to read-only using Python’s built-in modules. Although file system permissions can depend on the underlying OS and may not be perfect in all environments, it is a good practice.
• Create a new file called file\_protection.py and add code that will set the file to read-only. Insert the following code:

  
  import os
  import stat
  
  def set_file_readonly(file_path):
      # Change the file's mode to read-only
      os.chmod(file_path, stat.S_IREAD)
      

  
  


• In your main code file (for example, main.py), after importing your modules, call the function to lock your critical code file:
  

  
  from file_protection import set_file_readonly
  
  Set the locked code file to read-only
  set_file_readonly("locked_code.py")
      

  
  


• This step programmatically sets the file permissions, discouraging unintended edits.

 
Implementing File Integrity Verification
 

• Even with file permissions set, ensure that the content of locked\_code.py has not been altered. This is done by comparing its hash with a known value.
• Create a new file called integrity\_check.py and add the following code to verify file integrity:

  
  import hashlib
  
  def verify_locked_file(file_path, expected_hash):
      with open(file_path, "rb") as f:
          file_content = f.read()
      current_hash = hashlib.sha256(file_content).hexdigest()
      return current_hash == expected_hash
      

  
  


• In your main.py file, before executing any locked code, call this function to ensure that the file has not been tampered with. For example:
  

  
  from integrity_check import verify_locked_file
  
  Replace 'your_expected_hash_here' with the actual hash value obtained from a trusted source
  if not verify_locked_file("locked_code.py", "your_expected_hash_here"):
      raise Exception("The locked code file has been altered!")
      

  
  


• This verification step helps you detect any unintended modifications.

 
Encapsulating Locked Code through Module Import
 

• Keep the locked code encapsulated so that other parts of your project do not directly modify it. In your main.py or main entry file, only import from locked\_code.py without exposing its internal details.
• In main.py, import the locked function as follows:

  
  from locked_code import locked_function
  
  Use the locked function in your application logic
  result = locked_function()
  print(result)
      

  
  


• This practice prevents accidental edits by clearly demarcating which parts of your code are controlled and which are open to modifications.

 
Using Environment Variables for Sensitive Information
 

• For security best practices, avoid hard-coding sensitive details within your locked code. Instead, use environment variables or a secured configuration file that is not part of the locked code.
• If you need to include a dependency that manages environment settings, embed the code directly. Create a file named config.py:

  
  import os
  
  def get_important_config():
      # Use environment variables or defaults. For example:
      return os.getenv("IMPORTANT_SETTING", "default_value")
      

  
  


• Import and use this configuration in your locked code only if necessary. This keeps the locked code independent from configuration changes.