Version v0.2.109 - Simplify command line mode

Version v0.2.108 - Fixed piping issues
Version v0.2.107 - Update comments
2025-09-01 07:11:51 -04:00 · 2025-08-31 16:43:04 -04:00 · 2025-08-31 11:25:03 -04:00 · 2025-08-31 11:03:08 -04:00 · 2025-08-31 11:03:02 -04:00 · 2025-08-31 10:43:36 -04:00
15 changed files with 340 additions and 748 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -3,7 +3,4 @@ pads/
 Gemini.md
 TropicOfCancer-HenryMiller.txt

-# Auto-generated version files
-src/version.h
-src/version.c
-VERSION
+# Auto-generated files (none currently)
--- a/GENERIC_AUTOMATIC_VERSIONING_GUIDE.md
+++ b/GENERIC_AUTOMATIC_VERSIONING_GUIDE.md
@@ -1,361 +0,0 @@
-# Generic Automatic Version Increment System for Any Repository
-
-Here's a generalized implementation guide for adding automatic versioning to any project:
-
-## Core Concept
-**Automatic patch version increment with each build** - Every build automatically increments the patch version: v0.1.0 → v0.1.1 → v0.1.2, etc.
-
-## Implementation Steps
-
-### 1. Add Version Increment Function to Build Script
-Add this function to your build script (bash example):
-
-```bash
-# Function to automatically increment version
-increment_version() {
-    echo "[INFO] Incrementing version..."
-    
-    # Check if we're in a git repository
-    if ! git rev-parse --git-dir > /dev/null 2>&1; then
-        echo "[WARNING] Not in a git repository - skipping version increment"
-        return 0
-    fi
-    
-    # Get the highest version tag (not chronologically latest)
-    LATEST_TAG=$(git tag -l 'v*.*.*' | sort -V | tail -n 1 || echo "v0.1.0")
-    if [[ -z "$LATEST_TAG" ]]; then
-        LATEST_TAG="v0.1.0"
-    fi
-    
-    # Extract version components (remove 'v' prefix)
-    VERSION=${LATEST_TAG#v}
-    
-    # Parse major.minor.patch using regex
-    if [[ $VERSION =~ ^([0-9]+)\.([0-9]+)\.([0-9]+)$ ]]; then
-        MAJOR=${BASH_REMATCH[1]}
-        MINOR=${BASH_REMATCH[2]}
-        PATCH=${BASH_REMATCH[3]}
-    else
-        echo "[ERROR] Invalid version format in tag: $LATEST_TAG"
-        echo "[ERROR] Expected format: v0.1.0"
-        return 1
-    fi
-    
-    # Increment patch version
-    NEW_PATCH=$((PATCH + 1))
-    NEW_VERSION="v${MAJOR}.${MINOR}.${NEW_PATCH}"
-    
-    echo "[INFO] Current version: $LATEST_TAG"
-    echo "[INFO] New version: $NEW_VERSION"
-    
-    # Create new git tag
-    if git tag "$NEW_VERSION" 2>/dev/null; then
-        echo "[SUCCESS] Created new version tag: $NEW_VERSION"
-    else
-        echo "[WARNING] Tag $NEW_VERSION already exists - using existing version"
-        NEW_VERSION=$LATEST_TAG
-    fi
-    
-    # Update VERSION file for compatibility
-    echo "${NEW_VERSION#v}" > VERSION
-    echo "[SUCCESS] Updated VERSION file to ${NEW_VERSION#v}"
-}
-```
-
-### 2. Generate Version Header Files (For C/C++ Projects)
-Add this to the increment_version function:
-
-```bash
-# Generate version.h header file (adjust path as needed)
-cat > src/version.h << EOF
-/*
- * Auto-Generated Version Header
- * DO NOT EDIT THIS FILE MANUALLY - Generated by build script
- */
-
-#ifndef VERSION_H
-#define VERSION_H
-
-#define VERSION_MAJOR ${MAJOR}
-#define VERSION_MINOR ${MINOR}
-#define VERSION_PATCH ${NEW_PATCH}
-#define VERSION_STRING "${MAJOR}.${MINOR}.${NEW_PATCH}"
-#define VERSION_TAG "${NEW_VERSION}"
-
-/* Build information */
-#define BUILD_DATE "$(date +%Y-%m-%d)"
-#define BUILD_TIME "$(date +%H:%M:%S)"
-#define BUILD_TIMESTAMP "$(date '+%Y-%m-%d %H:%M:%S')"
-
-/* Git information */
-#define GIT_HASH "$(git rev-parse --short HEAD 2>/dev/null || echo 'unknown')"
-#define GIT_BRANCH "$(git rev-parse --abbrev-ref HEAD 2>/dev/null || echo 'unknown')"
-
-/* Display versions */
-#define VERSION_DISPLAY "${NEW_VERSION}"
-#define VERSION_FULL_DISPLAY "${NEW_VERSION} ($(date '+%Y-%m-%d %H:%M:%S'), $(git rev-parse --short HEAD 2>/dev/null || echo 'unknown'))"
-
-/* Version API functions */
-const char* get_version(void);
-const char* get_version_full(void);
-const char* get_build_info(void);
-
-#endif /* VERSION_H */
-EOF
-
-# Generate version.c implementation file
-cat > src/version.c << EOF
-/*
- * Auto-Generated Version Implementation
- * DO NOT EDIT THIS FILE MANUALLY - Generated by build script
- */
-
-#include "version.h"
-
-const char* get_version(void) {
-    return VERSION_TAG;
-}
-
-const char* get_version_full(void) {
-    return VERSION_FULL_DISPLAY;
-}
-
-const char* get_build_info(void) {
-    return "Built on " BUILD_DATE " at " BUILD_TIME " from commit " GIT_HASH " on branch " GIT_BRANCH;
-}
-EOF
-```
-
-### 3. Generate Version File for Other Languages
-
-**Python (`src/__version__.py`):**
-```bash
-cat > src/__version__.py << EOF
-"""Auto-generated version file"""
-__version__ = "${MAJOR}.${MINOR}.${NEW_PATCH}"
-__version_tag__ = "${NEW_VERSION}"
-__build_date__ = "$(date +%Y-%m-%d)"
-__build_time__ = "$(date +%H:%M:%S)"
-__git_hash__ = "$(git rev-parse --short HEAD 2>/dev/null || echo 'unknown')"
-__git_branch__ = "$(git rev-parse --abbrev-ref HEAD 2>/dev/null || echo 'unknown')"
-EOF
-```
-
-**JavaScript/Node.js (update `package.json`):**
-```bash
-# Update package.json version field
-if [ -f package.json ]; then
-    sed -i "s/\"version\": \".*\"/\"version\": \"${MAJOR}.${MINOR}.${NEW_PATCH}\"/" package.json
-fi
-```
-
-**Rust (update `Cargo.toml`):**
-```bash
-if [ -f Cargo.toml ]; then
-    sed -i "s/^version = \".*\"/version = \"${MAJOR}.${MINOR}.${NEW_PATCH}\"/" Cargo.toml
-fi
-```
-
-**Go (generate `version.go`):**
-```bash
-cat > version.go << EOF
-// Auto-generated version file
-package main
-
-const (
-    VersionMajor = ${MAJOR}
-    VersionMinor = ${MINOR}
-    VersionPatch = ${NEW_PATCH}
-    VersionString = "${MAJOR}.${MINOR}.${NEW_PATCH}"
-    VersionTag = "${NEW_VERSION}"
-    BuildDate = "$(date +%Y-%m-%d)"
-    BuildTime = "$(date +%H:%M:%S)"
-    GitHash = "$(git rev-parse --short HEAD 2>/dev/null || echo 'unknown')"
-    GitBranch = "$(git rev-parse --abbrev-ref HEAD 2>/dev/null || echo 'unknown')"
-)
-EOF
-```
-
-**Java (generate `Version.java`):**
-```bash
-cat > src/main/java/Version.java << EOF
-// Auto-generated version class
-public class Version {
-    public static final int VERSION_MAJOR = ${MAJOR};
-    public static final int VERSION_MINOR = ${MINOR};
-    public static final int VERSION_PATCH = ${NEW_PATCH};
-    public static final String VERSION_STRING = "${MAJOR}.${MINOR}.${NEW_PATCH}";
-    public static final String VERSION_TAG = "${NEW_VERSION}";
-    public static final String BUILD_DATE = "$(date +%Y-%m-%d)";
-    public static final String BUILD_TIME = "$(date +%H:%M:%S)";
-    public static final String GIT_HASH = "$(git rev-parse --short HEAD 2>/dev/null || echo 'unknown')";
-    public static final String GIT_BRANCH = "$(git rev-parse --abbrev-ref HEAD 2>/dev/null || echo 'unknown')";
-}
-EOF
-```
-
-### 4. Integrate into Build Targets
-Call `increment_version` before your main build commands:
-
-```bash
-build_library() {
-    increment_version
-    echo "[INFO] Building library..."
-    # Your actual build commands here
-    make clean && make
-}
-
-build_release() {
-    increment_version
-    echo "[INFO] Building release..."
-    # Your release build commands
-}
-
-build_package() {
-    increment_version
-    echo "[INFO] Building package..."
-    # Your packaging commands
-}
-```
-
-### 5. Update .gitignore
-Add generated version files to `.gitignore`:
-
-```gitignore
-# Auto-generated version files
-src/version.h
-src/version.c
-src/__version__.py
-version.go
-src/main/java/Version.java
-VERSION
-```
-
-### 6. Update Build System Files
-
-**For Makefile projects:**
-```makefile
-# Add version.c to your source files
-SOURCES = main.c utils.c version.c
-```
-
-**For CMake projects:**
-```cmake
-# Add version files to your target
-target_sources(your_target PRIVATE src/version.c)
-```
-
-**For Node.js projects:**
-```json
-{
-  "scripts": {
-    "build": "node build.js && increment_version",
-    "version": "node -e \"console.log(require('./package.json').version)\""
-  }
-}
-```
-
-### 7. Create Initial Version Tag
-```bash
-# Start with initial version
-git tag v0.1.0
-```
-
-## Usage Pattern
-```bash
-./build.sh          # v0.1.0 → v0.1.1
-./build.sh release  # v0.1.1 → v0.1.2
-./build.sh package  # v0.1.2 → v0.1.3
-```
-
-## Manual Version Control
-
-### Major/Minor Version Bumps
-```bash
-# For feature releases (minor bump)
-git tag v0.2.0  # Next build: v0.2.1
-
-# For breaking changes (major bump)
-git tag v1.0.0  # Next build: v1.0.1
-```
-
-### Version Reset
-```bash
-# Delete incorrect tags (if needed)
-git tag -d v0.2.1
-git push origin --delete v0.2.1  # If pushed to remote
-
-# Create correct base version
-git tag v0.2.0
-
-# Next build will create v0.2.1
-```
-
-## Example Build Script Template
-```bash
-#!/bin/bash
-set -e
-
-# Colors for output
-RED='\033[0;31m'
-GREEN='\033[0;32m'
-YELLOW='\033[1;33m'
-BLUE='\033[0;34m'
-NC='\033[0m'
-
-print_status() { echo -e "${BLUE}[INFO]${NC} $1"; }
-print_success() { echo -e "${GREEN}[SUCCESS]${NC} $1"; }
-print_warning() { echo -e "${YELLOW}[WARNING]${NC} $1"; }
-print_error() { echo -e "${RED}[ERROR]${NC} $1"; }
-
-# Insert increment_version function here
-
-case "${1:-build}" in
-    build)
-        increment_version
-        print_status "Building project..."
-        # Your build commands
-        ;;
-    clean)
-        print_status "Cleaning build artifacts..."
-        # Your clean commands
-        ;;
-    test)
-        print_status "Running tests..."
-        # Your test commands (no version increment)
-        ;;
-    release)
-        increment_version
-        print_status "Building release..."
-        # Your release commands
-        ;;
-    *)
-        echo "Usage: $0 {build|clean|test|release}"
-        exit 1
-        ;;
-esac
-```
-
-## Benefits
-1. **Zero maintenance** - No manual version editing
-2. **Build traceability** - Every build has unique version + metadata
-3. **Git integration** - Automatic version tags
-4. **Language agnostic** - Adapt generation for any language
-5. **CI/CD friendly** - Works in automated environments
-6. **Rollback friendly** - Easy to revert to previous versions
-
-## Troubleshooting
-
-### Version Not Incrementing
- Ensure you're in a git repository
- Check that git tags exist: `git tag --list`
- Verify tag format matches `v*.*.*` pattern
-
-### Tag Already Exists
-If a tag already exists, the build continues with existing version:
-```
-[WARNING] Tag v0.2.1 already exists - using existing version
-```
-
-### Missing Git Information
-If git is unavailable, version files show "unknown" for git hash and branch.
--- a/README.md
+++ b/README.md
@@ -151,10 +151,7 @@ git tag v1.0.0    # Next build: v1.0.1
 - Full version display with metadata

 ### Generated Files
-The build system automatically generates:
- `src/version.h` - Version constants and macros
- `src/version.c` - Version API functions  
- `VERSION` - Plain text version number
+The build system automatically manages Git versioning by incrementing tags.

 These files are excluded from git (.gitignore) and regenerated on each build.

@@ -176,9 +173,6 @@ otp/
 ├── otp.c            # Main source code
 ├── README.md        # This file
 ├── .gitignore       # Git ignore rules
-├── src/             # Generated version files (auto-created)
-│   ├── version.h    # Version header (generated)
-│   └── version.c    # Version implementation (generated)
 ├── pads/            # OTP pad storage directory (created at runtime)
 └── VERSION          # Plain text version (generated)
 ```
--- a/build.sh
+++ b/build.sh
@@ -100,13 +100,13 @@ increment_version() {
        print_success "Created new version tag: $NEW_VERSION"
        
        # Push changes and tags to remote repository
-        if git push ssh://ubuntu@laantungir.net:/home/ubuntu/git_repos/otp 2>/dev/null; then
+        if git push 2>/dev/null; then
            print_success "Pushed changes to remote repository"
        else
            print_warning "Failed to push changes to remote repository"
        fi
        
-        if git push ssh://ubuntu@laantungir.net:/home/ubuntu/git_repos/otp --tags 2>/dev/null; then
+        if git push --tags 2>/dev/null; then
            print_success "Pushed tags to remote repository"
        else
            print_warning "Failed to push tags to remote repository"
@@ -123,71 +123,31 @@ increment_version() {
        fi
    fi
    
-    # Update VERSION file for compatibility
-    echo "${NEW_VERSION#v}" > VERSION
-    print_success "Updated VERSION file to ${NEW_VERSION#v}"
+    # Update version strings in source code
+    update_source_version "$NEW_VERSION"
    
-    # Generate version.h header file
-    mkdir -p src
-    cat > src/version.h << EOF
-/*
- * Auto-Generated Version Header
- * DO NOT EDIT THIS FILE MANUALLY - Generated by build script
- */
-
-#ifndef VERSION_H
-#define VERSION_H
-
-#define VERSION_MAJOR ${MAJOR}
-#define VERSION_MINOR ${MINOR}
-#define VERSION_PATCH ${NEW_PATCH}
-#define VERSION_STRING "${MAJOR}.${MINOR}.${NEW_PATCH}"
-#define VERSION_TAG "${NEW_VERSION}"
-
-/* Build information */
-#define BUILD_DATE "$(date +%Y-%m-%d)"
-#define BUILD_TIME "$(date +%H:%M:%S)"
-#define BUILD_TIMESTAMP "$(date '+%Y-%m-%d %H:%M:%S')"
-
-/* Git information */
-#define GIT_HASH "$(git rev-parse --short HEAD 2>/dev/null || echo 'unknown')"
-#define GIT_BRANCH "$(git rev-parse --abbrev-ref HEAD 2>/dev/null || echo 'unknown')"
-
-/* Display versions */
-#define VERSION_DISPLAY "${NEW_VERSION}"
-#define VERSION_FULL_DISPLAY "${NEW_VERSION} ($(date '+%Y-%m-%d %H:%M:%S'), $(git rev-parse --short HEAD 2>/dev/null || echo 'unknown'))"
-
-/* Version API functions */
-const char* get_version(void);
-const char* get_version_full(void);
-const char* get_build_info(void);
-
-#endif /* VERSION_H */
-EOF
-
-    # Generate version.c implementation file
-    cat > src/version.c << EOF
-/*
- * Auto-Generated Version Implementation
- * DO NOT EDIT THIS FILE MANUALLY - Generated by build script
- */
-
-#include "version.h"
-
-const char* get_version(void) {
-    return VERSION_TAG;
+    print_success "Version updated to ${NEW_VERSION}"
 }

-const char* get_version_full(void) {
-    return VERSION_FULL_DISPLAY;
-}
-
-const char* get_build_info(void) {
-    return "Built on " BUILD_DATE " at " BUILD_TIME " from commit " GIT_HASH " on branch " GIT_BRANCH;
-}
-EOF
-
-    print_success "Generated version header files"
+# Function to update version strings in source code
+update_source_version() {
+    local NEW_VERSION="$1"
+    
+    print_status "Updating version strings in source code..."
+    
+    # Replace hardcoded version strings in otp.c with the current git tag
+    if [ -f "otp.c" ]; then
+        # Update main menu version
+        sed -i "s/OTP v[0-9]\+\.[0-9]\+\.[0-9]\+/OTP $NEW_VERSION/g" otp.c
+        # Update ASCII output version
+        sed -i "s/Version: v[0-9]\+\.[0-9]\+\.[0-9]\+/Version: $NEW_VERSION/g" otp.c
+        # Update usage/help text version
+        sed -i "s/Implementation v[0-9]\+\.[0-9]\+\.[0-9]\+/Implementation $NEW_VERSION/g" otp.c
+        
+        print_success "Updated version strings in otp.c to $NEW_VERSION"
+    else
+        print_warning "otp.c not found - skipping version string updates"
+    fi
 }

 # Build functions
@@ -222,7 +182,6 @@ build_static() {
 clean_project() {
    print_status "Cleaning build artifacts..."
    make clean
-    rm -f VERSION src/version.h src/version.c
    print_success "Clean completed"
 }

@@ -265,28 +224,23 @@ case "${1:-build}" in
    uninstall)
        uninstall_project
        ;;
-    version)
-        increment_version
-        print_status "Version information generated"
-        ;;
    *)
        echo "OTP Cipher Build Script"
-        echo "Usage: $0 [-m \"commit message\"] {build|static|clean|install|uninstall|version}"
+        echo "Usage: $0 [-m \"commit message\"] {build|static|clean|install|uninstall}"
        echo ""
        echo "Options:"
        echo "  -m, --message \"text\"  - Specify commit message (skips interactive prompt)"
        echo ""
        echo "Commands:"
        echo "  build     - Build project with automatic version increment (default)"
-        echo "  static    - Build with static linking"
-        echo "  clean     - Clean build artifacts and generated files"
+        echo "  static    - Build with static linking and version increment"
+        echo "  clean     - Clean build artifacts"
        echo "  install   - Install to system (requires build first)"
        echo "  uninstall - Remove from system"
-        echo "  version   - Generate version files only"
        echo ""
        echo "Examples:"
-        echo "  $0 build"
-        echo "  $0 -m \"Fixed checksum parsing bug\" build"
+        echo "  $0"
+        echo "  $0 -m \"Fixed checksum parsing bug\""
        echo "  $0 --message \"Added new feature\" static"
        exit 1
        ;;
--- a/files/out2.otp
+++ b/files/out2.otp
--- a/files/output.otp
+++ b/files/output.otp
--- a/files/test_decrypt.txt
+++ b/files/test_decrypt.txt
@@ -1 +0,0 @@
-Test file content for decryption
--- a/files/test_decrypt.txt.otp
+++ b/files/test_decrypt.txt.otp
--- a/files/test_file.txt
+++ b/files/test_file.txt
@@ -1 +0,0 @@
-Hello, this is a test file for encryption!
--- a/files/test_file.txt.otp.asc
+++ b/files/test_file.txt.otp.asc
@@ -1,7 +0,0 @@
-----BEGIN OTP MESSAGE-----
-Version: v0.2.29
-Pad-ChkSum: d0d4a489354348b08d8c7b324814d8c50010042e9da47f2c973f32a16a09101b
-Pad-Offset: 57
-
-05S8GfS0tFfczNMUz0xrieFGoPSREM4uo5QhFGoBCcOzjfTXTDMt3hRtAQ==
-----END OTP MESSAGE-----
--- a/files/test_files_dir.txt.otp
+++ b/files/test_files_dir.txt.otp
--- a/files/test_input.txt
+++ b/files/test_input.txt
@@ -1 +0,0 @@
-This is a test file for encryption.
--- a/files/toc.txt.otp
+++ b/files/toc.txt.otp
--- a/otp.c
+++ b/otp.c
@@ -58,6 +58,9 @@ static char current_pads_dir[512] = DEFAULT_PADS_DIR;
 // Global variable for default pad path from preferences
 static char default_pad_path[1024] = "";

+// Global variable for interactive mode detection
+static int is_interactive_mode = 0;
+
 // Function prototypes
 int main(int argc, char* argv[]);
 int interactive_mode(void);
@@ -89,7 +92,6 @@ int launch_file_manager(const char* start_directory, char* selected_file, size_t
 int generate_pad(uint64_t size_bytes, int show_progress);
 int encrypt_text(const char* pad_identifier, const char* input_text);
 int decrypt_text(const char* pad_identifier, const char* encrypted_message);
-int decrypt_text_silent(const char* pad_identifier, const char* encrypted_message);
 int encrypt_file(const char* pad_identifier, const char* input_file, const char* output_file, int ascii_armor);
 int decrypt_file(const char* input_file, const char* output_file);
 int decrypt_binary_file(FILE* input_fp, const char* output_file);
@@ -197,19 +199,14 @@ int main(int argc, char* argv[]) {
    // Load preferences first
    load_preferences();
    
-    // Check for piped input first (before any output)
-    int is_pipe_mode = (argc == 1 && has_stdin_data());
-    
-    // Check for decrypt command with piped input
-    int is_decrypt_pipe = (argc == 2 && 
-                          (strcmp(argv[1], "decrypt") == 0 || strcmp(argv[1], "-d") == 0) && 
-                          has_stdin_data());
+    // Detect interactive mode: only true when running with no arguments
+    is_interactive_mode = (argc == 1);
    
    // Check for OTP thumb drive on startup
    char otp_drive_path[512];
    if (detect_otp_thumb_drive(otp_drive_path, sizeof(otp_drive_path))) {
-        // Only show messages in interactive/command mode, not pipe mode
-        if (!is_pipe_mode && !is_decrypt_pipe) {
+        // Only show messages in interactive mode
+        if (is_interactive_mode) {
            printf("Detected OTP thumb drive: %s\n", otp_drive_path);
            printf("Using as default pads directory for this session.\n\n");
        }
@@ -217,17 +214,7 @@ int main(int argc, char* argv[]) {
        current_pads_dir[sizeof(current_pads_dir) - 1] = '\0';
    }
    
-    if (is_pipe_mode) {
-        // No arguments but has piped data - enter pipe mode
-        char* piped_text = read_stdin_text();
-        if (piped_text) {
-            int result = pipe_mode(argc, argv, piped_text);
-            free(piped_text);
-            return result;
-        }
-        // If reading stdin failed, fall back to interactive mode
-        return interactive_mode();
-    } else if (argc == 1) {
+    if (is_interactive_mode) {
        return interactive_mode();
    } else {
        return command_line_mode(argc, argv);
@@ -244,8 +231,8 @@ int main(int argc, char* argv[]) {

 int command_line_mode(int argc, char* argv[]) {
    // Check for help flags first
-    if (strcmp(argv[1], "-h") == 0 || strcmp(argv[1], "--h") == 0 || 
-        strcmp(argv[1], "-help") == 0 || strcmp(argv[1], "--help") == 0 || 
+    if (strcmp(argv[1], "-h") == 0 || strcmp(argv[1], "--h") == 0 ||
+        strcmp(argv[1], "-help") == 0 || strcmp(argv[1], "--help") == 0 ||
        strcmp(argv[1], "help") == 0) {
        print_usage(argv[0]);
        return 0;
@@ -265,6 +252,16 @@ int command_line_mode(int argc, char* argv[]) {
        return generate_pad(size, 1);  // Use simplified pad generation
    }
    else if (strcmp(argv[1], "encrypt") == 0 || strcmp(argv[1], "-e") == 0) {
+        // Check for piped input first
+        if (has_stdin_data()) {
+            char* piped_text = read_stdin_text();
+            if (piped_text) {
+                int result = pipe_mode(argc, argv, piped_text);
+                free(piped_text);
+                return result;
+            }
+        }
+        
        if (argc < 2 || argc > 4) {
            printf("Usage: %s encrypt|-e [pad_chksum_or_prefix] [text_to_encrypt]\n", argv[0]);
            return 1;
@@ -334,7 +331,7 @@ int command_line_mode(int argc, char* argv[]) {
                // Piped decrypt mode - read stdin and decrypt silently
                char* piped_message = read_stdin_text();
                if (piped_message) {
-                    int result = decrypt_text_silent(NULL, piped_message);
+                    int result = decrypt_text(NULL, piped_message);
                    free(piped_message);
                    return result;
                }
@@ -346,7 +343,7 @@ int command_line_mode(int argc, char* argv[]) {
            // Check if the argument looks like an encrypted message (starts with -----)
            if (strncmp(argv[2], "-----BEGIN OTP MESSAGE-----", 27) == 0) {
                // Inline decrypt with message only - use silent mode for command line
-                return decrypt_text_silent(NULL, argv[2]);
+                return decrypt_text(NULL, argv[2]);
            } else {
                // Check if it's a file (contains . or ends with known extensions)
                if (strstr(argv[2], ".") != NULL) {
@@ -366,7 +363,7 @@ int command_line_mode(int argc, char* argv[]) {
            } else {
                // Legacy format: pad_chksum and message, or file with output
                // Use silent mode for command line when message is provided
-                return decrypt_text_silent(argv[2], argv[3]);
+                return decrypt_text(argv[2], argv[3]);
            }
        }
        else if (argc == 5 && strcmp(argv[3], "-o") == 0) {
@@ -467,7 +464,7 @@ int interactive_mode(void) {
 void show_main_menu(void) {


-    printf("\n=========================== Main Menu - OTP v1.0.0 ===========================\n\n");
+    printf("\n=========================== Main Menu - OTP v0.2.108 ===========================\n\n");

    printf(" \033[4mT\033[0mext encrypt\n");    //TEXT ENCRYPT
    printf(" \033[4mF\033[0mile encrypt\n");    //FILE ENCRYPT
@@ -1249,6 +1246,17 @@ int add_entropy_to_pad(const char* pad_chksum, const unsigned char* entropy_data
    return 0;
 }

+
+
+////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+//      ENCRYPT AND DECRYPT
+////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+
+
+
+
 int encrypt_text(const char* pad_identifier, const char* input_text) {
    char* pad_chksum = find_pad_by_prefix(pad_identifier);
    if (!pad_chksum) {
@@ -1300,23 +1308,29 @@ int encrypt_text(const char* pad_identifier, const char* input_text) {
        text_buffer[sizeof(text_buffer) - 1] = '\0';
    } else {
        // Get input text from user (interactive mode)
-        printf("\nText input options:\n");
-        printf(" 1. Type text directly\n");
-        printf(" 2. Use text editor\n");
-        printf("Enter choice (1-2): ");
-        
-        char input_choice[10];
-        if (!fgets(input_choice, sizeof(input_choice), stdin)) {
-            printf("Error: Failed to read input\n");
-            free(pad_chksum);
-            return 1;
+        if (is_interactive_mode) {
+            printf("\nText input options:\n");
+            printf(" 1. Type text directly\n");
+            printf(" 2. Use text editor\n");
+            printf("Enter choice (1-2): ");
        }
        
-        if (atoi(input_choice) == 2) {
+        char input_choice[10] = "1"; // Default to direct input in non-interactive mode
+        if (is_interactive_mode) {
+            if (!fgets(input_choice, sizeof(input_choice), stdin)) {
+                printf("Error: Failed to read input\n");
+                free(pad_chksum);
+                return 1;
+            }
+        }
+        
+        if (is_interactive_mode && atoi(input_choice) == 2) {
            // Use text editor
            if (launch_text_editor(NULL, text_buffer, sizeof(text_buffer)) != 0) {
-                printf("Falling back to direct text input.\n");
-                printf("Enter text to encrypt: ");
+                if (is_interactive_mode) {
+                    printf("Falling back to direct text input.\n");
+                    printf("Enter text to encrypt: ");
+                }
                fflush(stdout);
                
                if (fgets(text_buffer, sizeof(text_buffer), stdin) == NULL) {
@@ -1333,8 +1347,10 @@ int encrypt_text(const char* pad_identifier, const char* input_text) {
            }
        } else {
            // Direct text input
-            printf("Enter text to encrypt: ");
-            fflush(stdout);
+            if (is_interactive_mode) {
+                printf("Enter text to encrypt: ");
+                fflush(stdout);
+            }
            
            if (fgets(text_buffer, sizeof(text_buffer), stdin) == NULL) {
                printf("Error: Failed to read input\n");
@@ -1442,16 +1458,12 @@ int encrypt_text(const char* pad_identifier, const char* input_text) {
 }

 int decrypt_text(const char* pad_identifier, const char* encrypted_message) {
-    // Use universal decrypt function with interactive mode
+    // Use universal decrypt function with mode based on global interactive mode detection
    (void)pad_identifier; // Suppress unused parameter warning - chksum comes from message
-    return universal_decrypt(encrypted_message, NULL, DECRYPT_MODE_INTERACTIVE);
+    decrypt_mode_t mode = is_interactive_mode ? DECRYPT_MODE_INTERACTIVE : DECRYPT_MODE_SILENT;
+    return universal_decrypt(encrypted_message, NULL, mode);
 }

-int decrypt_text_silent(const char* pad_identifier, const char* encrypted_message) {
-    // Use universal decrypt function with silent mode
-    (void)pad_identifier; // Suppress unused parameter warning - chksum comes from message
-    return universal_decrypt(encrypted_message, NULL, DECRYPT_MODE_SILENT);
-}

 int encrypt_file(const char* pad_identifier, const char* input_file, const char* output_file, int ascii_armor) {
    char* pad_chksum = find_pad_by_prefix(pad_identifier);
@@ -1926,190 +1938,14 @@ int write_state_offset(const char* pad_chksum, uint64_t offset) {
    return 0;
 }

-int calculate_checksum(const char* filename, char* checksum_hex) {
-    FILE* file = fopen(filename, "rb");
-    if (!file) {
-        return 1;
-    }
-    
-    unsigned char checksum[32];
-    unsigned char buffer[64 * 1024];  // 64KB buffer for large files
-    size_t bytes_read;
-    
-    // Initialize checksum
-    memset(checksum, 0, 32);
-    size_t total_bytes = 0;
-    
-    // Calculate XOR checksum of entire file
-    while ((bytes_read = fread(buffer, 1, sizeof(buffer), file)) > 0) {
-        // Process this chunk with XOR checksum
-        for (size_t i = 0; i < bytes_read; i++) {
-            unsigned char bucket = (total_bytes + i) % 32;
-            checksum[bucket] ^= buffer[i] ^ (((total_bytes + i) >> 8) & 0xFF) ^ 
-                               (((total_bytes + i) >> 16) & 0xFF) ^ (((total_bytes + i) >> 24) & 0xFF);
-        }
-        total_bytes += bytes_read;
-    }
-    
-    fclose(file);
-    
-    // Now encrypt the checksum with the first 32 bytes of the pad
-    fseek(file = fopen(filename, "rb"), 0, SEEK_SET);
-    unsigned char pad_key[32];
-    if (fread(pad_key, 1, 32, file) != 32) {
-        fclose(file);
-        return 1;
-    }
-    fclose(file);
-    
-    // XOR encrypt the checksum with pad data to create unique identifier
-    unsigned char encrypted_checksum[32];
-    for (int i = 0; i < 32; i++) {
-        encrypted_checksum[i] = checksum[i] ^ pad_key[i];
-    }
-    
-    // Convert to hex string (64 characters)
-    for (int i = 0; i < 32; i++) {
-        sprintf(checksum_hex + (i * 2), "%02x", encrypted_checksum[i]);
-    }
-    checksum_hex[64] = '\0';
-    
-    return 0;
-}

-// Keyboard entropy functions
-int setup_raw_terminal(struct termios* original_termios) {
-    struct termios new_termios;
-    
-    if (tcgetattr(STDIN_FILENO, original_termios) != 0) {
-        return 1;
-    }
-    
-    new_termios = *original_termios;
-    new_termios.c_lflag &= ~(ICANON | ECHO);
-    new_termios.c_cc[VMIN] = 0;
-    new_termios.c_cc[VTIME] = 0;
-    
-    if (tcsetattr(STDIN_FILENO, TCSANOW, &new_termios) != 0) {
-        return 1;
-    }
-    
-    // Set stdin to non-blocking
-    int flags = fcntl(STDIN_FILENO, F_GETFL);
-    if (fcntl(STDIN_FILENO, F_SETFL, flags | O_NONBLOCK) == -1) {
-        tcsetattr(STDIN_FILENO, TCSANOW, original_termios);
-        return 1;
-    }
-    
-    return 0;
-}

-void restore_terminal(struct termios* original_termios) {
-    tcsetattr(STDIN_FILENO, TCSANOW, original_termios);
-    
-    // Reset stdin to blocking
-    int flags = fcntl(STDIN_FILENO, F_GETFL);
-    fcntl(STDIN_FILENO, F_SETFL, flags & ~O_NONBLOCK);
-}

-// Enhanced entropy collection with visual feedback
-int collect_entropy_with_feedback(unsigned char* entropy_buffer, size_t target_bytes,
-                                 size_t* collected_bytes, int allow_early_exit) {
-    struct termios original_termios;
-    entropy_collection_state_t state = {0};
-    
-    // Initialize state
-    state.target_bytes = target_bytes;
-    state.auto_complete_enabled = allow_early_exit;
-    state.collection_start_time = get_precise_time();
-    
-    // Setup raw terminal
-    if (setup_raw_terminal(&original_termios) != 0) {
-        printf("Error: Cannot setup terminal for entropy collection\n");
-        return 1;
-    }
-    
-    // Clear screen area for display
-    printf("\n\n\n\n\n\n");
-    
-    unsigned char entropy_block[16];
-    struct timespec timestamp;
-    uint32_t sequence_counter = 0;
-    char key;
-    unsigned char seen_keys[256] = {0};
-    
-    *collected_bytes = 0;
-    
-    while (state.collected_bytes < target_bytes) {
-        // Update display
-        state.quality_score = calculate_overall_quality(&state);
-        display_entropy_progress(&state);
-        
-        // Non-blocking read
-        if (read(STDIN_FILENO, &key, 1) == 1) {
-            // Handle ESC key for early exit
-            if (key == 27 && allow_early_exit && state.collected_bytes >= 1024) {
-                break; // Early exit allowed
-            }
-            
-            // Record keypress timing
-            double current_time = get_precise_time();
-            state.last_keypress_time = current_time;
-            
-            // Update key histogram
-            state.key_histogram[(unsigned char)key]++;
-            
-            // Get high precision timestamp
-            clock_gettime(CLOCK_MONOTONIC, &timestamp);
-            
-            // Create enhanced entropy block: [key][timestamp][sequence][quality_bits]
-            entropy_block[0] = key;
-            memcpy(&entropy_block[1], &timestamp.tv_sec, 8);
-            memcpy(&entropy_block[9], &timestamp.tv_nsec, 4);
-            memcpy(&entropy_block[13], &sequence_counter, 2);
-            entropy_block[15] = (unsigned char)(current_time * 1000) & 0xFF; // Sub-millisecond timing
-            
-            // Add to entropy buffer
-            if (state.collected_bytes + 16 <= MAX_ENTROPY_BUFFER) {
-                memcpy(entropy_buffer + state.collected_bytes, entropy_block, 16);
-                state.collected_bytes += 16;
-            }
-            
-            sequence_counter++;
-            
-            // Track unique keys
-            if (!seen_keys[(unsigned char)key]) {
-                seen_keys[(unsigned char)key] = 1;
-                state.unique_keys++;
-            }
-        } else {
-            // No key available, just sleep and wait for keystrokes
-            usleep(10000); // 10ms delay - wait for keystrokes, don't add timing entropy
-        }
-        
-        // Auto-complete at target if enabled
-        if (state.collected_bytes >= target_bytes) {
-            break;
-        }
-    }
-    
-    // Final display update
-    state.quality_score = calculate_overall_quality(&state);
-    display_entropy_progress(&state);
-    
-    // Summary
-    double collection_time = get_precise_time() - state.collection_start_time;
-    printf("\n\n✓ Entropy collection complete!\n");
-    printf("  Collected: %zu bytes in %.1f seconds\n", state.collected_bytes, collection_time);
-    printf("  Quality: %d%% (Excellent: 80%%+, Good: 60%%+)\n", state.quality_score);
-    printf("  Unique keys: %zu\n", state.unique_keys);
-    
-    // Restore terminal
-    restore_terminal(&original_termios);
-    
-    *collected_bytes = state.collected_bytes;
-    return 0;
-}
+
+
+
+
+


 // Directory management functions
@@ -2599,7 +2435,14 @@ unsigned char* custom_base64_decode(const char* input, int* output_length) {
    return decoded;
 }

-// Enhanced entropy system implementation
+
+
+////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+//      ADD ENTROPY
+////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+

 double get_precise_time(void) {
    struct timespec ts;
@@ -2797,7 +2640,6 @@ int derive_chacha20_params(const unsigned char* entropy_data, size_t entropy_siz
    return 0; // Success
 }

-// Enhanced entropy system helper functions

 // Check if a pad is unused (0% usage)
 int is_pad_unused(const char* pad_chksum) {
@@ -2888,6 +2730,143 @@ int update_pad_checksum_after_entropy(const char* old_chksum, char* new_chksum)
    return 0; // Success
 }

+// Enhanced entropy collection with visual feedback
+int collect_entropy_with_feedback(unsigned char* entropy_buffer, size_t target_bytes,
+                                 size_t* collected_bytes, int allow_early_exit) {
+    struct termios original_termios;
+    entropy_collection_state_t state = {0};
+    
+    // Initialize state
+    state.target_bytes = target_bytes;
+    state.auto_complete_enabled = allow_early_exit;
+    state.collection_start_time = get_precise_time();
+    
+    // Setup raw terminal
+    if (setup_raw_terminal(&original_termios) != 0) {
+        printf("Error: Cannot setup terminal for entropy collection\n");
+        return 1;
+    }
+    
+    // Clear screen area for display
+    printf("\n\n\n\n\n\n");
+    
+    unsigned char entropy_block[16];
+    struct timespec timestamp;
+    uint32_t sequence_counter = 0;
+    char key;
+    unsigned char seen_keys[256] = {0};
+    
+    *collected_bytes = 0;
+    
+    while (state.collected_bytes < target_bytes) {
+        // Update display
+        state.quality_score = calculate_overall_quality(&state);
+        display_entropy_progress(&state);
+        
+        // Non-blocking read
+        if (read(STDIN_FILENO, &key, 1) == 1) {
+            // Handle ESC key for early exit
+            if (key == 27 && allow_early_exit && state.collected_bytes >= 1024) {
+                break; // Early exit allowed
+            }
+            
+            // Record keypress timing
+            double current_time = get_precise_time();
+            state.last_keypress_time = current_time;
+            
+            // Update key histogram
+            state.key_histogram[(unsigned char)key]++;
+            
+            // Get high precision timestamp
+            clock_gettime(CLOCK_MONOTONIC, &timestamp);
+            
+            // Create enhanced entropy block: [key][timestamp][sequence][quality_bits]
+            entropy_block[0] = key;
+            memcpy(&entropy_block[1], &timestamp.tv_sec, 8);
+            memcpy(&entropy_block[9], &timestamp.tv_nsec, 4);
+            memcpy(&entropy_block[13], &sequence_counter, 2);
+            entropy_block[15] = (unsigned char)(current_time * 1000) & 0xFF; // Sub-millisecond timing
+            
+            // Add to entropy buffer
+            if (state.collected_bytes + 16 <= MAX_ENTROPY_BUFFER) {
+                memcpy(entropy_buffer + state.collected_bytes, entropy_block, 16);
+                state.collected_bytes += 16;
+            }
+            
+            sequence_counter++;
+            
+            // Track unique keys
+            if (!seen_keys[(unsigned char)key]) {
+                seen_keys[(unsigned char)key] = 1;
+                state.unique_keys++;
+            }
+        } else {
+            // No key available, just sleep and wait for keystrokes
+            usleep(10000); // 10ms delay - wait for keystrokes, don't add timing entropy
+        }
+        
+        // Auto-complete at target if enabled
+        if (state.collected_bytes >= target_bytes) {
+            break;
+        }
+    }
+    
+    // Final display update
+    state.quality_score = calculate_overall_quality(&state);
+    display_entropy_progress(&state);
+    
+    // Summary
+    double collection_time = get_precise_time() - state.collection_start_time;
+    printf("\n\n✓ Entropy collection complete!\n");
+    printf("  Collected: %zu bytes in %.1f seconds\n", state.collected_bytes, collection_time);
+    printf("  Quality: %d%% (Excellent: 80%%+, Good: 60%%+)\n", state.quality_score);
+    printf("  Unique keys: %zu\n", state.unique_keys);
+    
+    // Restore terminal
+    restore_terminal(&original_termios);
+    
+    *collected_bytes = state.collected_bytes;
+    return 0;
+}
+
+// Keyboard entropy functions
+int setup_raw_terminal(struct termios* original_termios) {
+    struct termios new_termios;
+    
+    if (tcgetattr(STDIN_FILENO, original_termios) != 0) {
+        return 1;
+    }
+    
+    new_termios = *original_termios;
+    new_termios.c_lflag &= ~(ICANON | ECHO);
+    new_termios.c_cc[VMIN] = 0;
+    new_termios.c_cc[VTIME] = 0;
+    
+    if (tcsetattr(STDIN_FILENO, TCSANOW, &new_termios) != 0) {
+        return 1;
+    }
+    
+    // Set stdin to non-blocking
+    int flags = fcntl(STDIN_FILENO, F_GETFL);
+    if (fcntl(STDIN_FILENO, F_SETFL, flags | O_NONBLOCK) == -1) {
+        tcsetattr(STDIN_FILENO, TCSANOW, original_termios);
+        return 1;
+    }
+    
+    return 0;
+}
+
+void restore_terminal(struct termios* original_termios) {
+    tcsetattr(STDIN_FILENO, TCSANOW, original_termios);
+    
+    // Reset stdin to blocking
+    int flags = fcntl(STDIN_FILENO, F_GETFL);
+    fcntl(STDIN_FILENO, F_SETFL, flags & ~O_NONBLOCK);
+}
+
+
+
+
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 //      UNIVERSAL CORE FUNCTIONS FOR CODE CONSOLIDATION
@@ -2978,8 +2957,8 @@ int load_pad_data(const char* pad_chksum, uint64_t offset, size_t length, unsign
        return 1; // Error: null pointer
    }
    
-    char pad_path[MAX_HASH_LENGTH + 20];
-    char state_path[MAX_HASH_LENGTH + 20];
+    char pad_path[1024];
+    char state_path[1024];
    get_pad_path(pad_chksum, pad_path, state_path);
    
    // Check if pad file exists
@@ -3058,7 +3037,7 @@ int generate_ascii_armor(const char* chksum, uint64_t offset, const unsigned cha
    strcpy(*ascii_output, "-----BEGIN OTP MESSAGE-----\n");
    
    char temp_line[256];
-    snprintf(temp_line, sizeof(temp_line), "Version: v1.0.0\n");
+    snprintf(temp_line, sizeof(temp_line), "Version: v0.2.108\n");
    strcat(*ascii_output, temp_line);
    
    snprintf(temp_line, sizeof(temp_line), "Pad-ChkSum: %s\n", chksum);
@@ -3314,17 +3293,28 @@ int universal_decrypt(const char* input_data, const char* output_target, decrypt
            printf("Note: ASCII format does not preserve original filename/permissions\n");
        }
    } else {
-        // Text output to stdout
-        ciphertext[ciphertext_len] = '\0';
+        // Text output to stdout - need to allocate space for null terminator
+        char* decrypted_text = malloc(ciphertext_len + 1);
+        if (!decrypted_text) {
+            printf("Error: Memory allocation failed for output\n");
+            free(ciphertext);
+            free(pad_data);
+            return 1;
+        }
+        
+        memcpy(decrypted_text, ciphertext, ciphertext_len);
+        decrypted_text[ciphertext_len] = '\0';
        
        if (mode == DECRYPT_MODE_SILENT) {
            // Silent mode - just output the text
-            printf("%s\n", (char*)ciphertext);
+            printf("%s\n", decrypted_text);
            fflush(stdout);
        } else {
            // Interactive mode - with label
-            printf("Decrypted: %s\n", (char*)ciphertext);
+            printf("Decrypted: %s\n", decrypted_text);
        }
+        
+        free(decrypted_text);
    }
    
    // Cleanup
@@ -3522,7 +3512,12 @@ int get_filename_with_default(const char* prompt, const char* default_path, char
    return 0;
 }

-// Editor and file manager implementations
+////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+//      EDITOR AND FILE MANAGER
+////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+

 char* get_preferred_editor(void) {
    // Check EDITOR environment variable first
@@ -3797,6 +3792,65 @@ int handle_file_encrypt(void) {
 }


+
+////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+//      PADS
+////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+
+
+int calculate_checksum(const char* filename, char* checksum_hex) {
+    FILE* file = fopen(filename, "rb");
+    if (!file) {
+        return 1;
+    }
+    
+    unsigned char checksum[32];
+    unsigned char buffer[64 * 1024];  // 64KB buffer for large files
+    size_t bytes_read;
+    
+    // Initialize checksum
+    memset(checksum, 0, 32);
+    size_t total_bytes = 0;
+    
+    // Calculate XOR checksum of entire file
+    while ((bytes_read = fread(buffer, 1, sizeof(buffer), file)) > 0) {
+        // Process this chunk with XOR checksum
+        for (size_t i = 0; i < bytes_read; i++) {
+            unsigned char bucket = (total_bytes + i) % 32;
+            checksum[bucket] ^= buffer[i] ^ (((total_bytes + i) >> 8) & 0xFF) ^ 
+                               (((total_bytes + i) >> 16) & 0xFF) ^ (((total_bytes + i) >> 24) & 0xFF);
+        }
+        total_bytes += bytes_read;
+    }
+    
+    fclose(file);
+    
+    // Now encrypt the checksum with the first 32 bytes of the pad
+    fseek(file = fopen(filename, "rb"), 0, SEEK_SET);
+    unsigned char pad_key[32];
+    if (fread(pad_key, 1, 32, file) != 32) {
+        fclose(file);
+        return 1;
+    }
+    fclose(file);
+    
+    // XOR encrypt the checksum with pad data to create unique identifier
+    unsigned char encrypted_checksum[32];
+    for (int i = 0; i < 32; i++) {
+        encrypted_checksum[i] = checksum[i] ^ pad_key[i];
+    }
+    
+    // Convert to hex string (64 characters)
+    for (int i = 0; i < 32; i++) {
+        sprintf(checksum_hex + (i * 2), "%02x", encrypted_checksum[i]);
+    }
+    checksum_hex[64] = '\0';
+    
+    return 0;
+}
+
 // Unified pad selection function - extracts the best UI from handle_pads_menu()
 char* select_pad_interactive(const char* title, const char* prompt, pad_filter_type_t filter_type, int allow_cancel) {
    // Get list of pads from current directory
@@ -3991,7 +4045,7 @@ char* select_pad_interactive(const char* title, const char* prompt, pad_filter_t
                for (int i = 0; i < pad_count; i++) {
                    if (strncmp(pads[i].chksum, default_checksum, 64) == 0) {
                        free(current_default);
-                        printf("Selected default pad: %.16s...\n", default_checksum);
+                        printf("Selected default pad: %.16s...\n\n", default_checksum);
                        return strdup(default_checksum);
                    }
                }
@@ -4215,7 +4269,7 @@ int handle_pads_menu(void) {
    printf(" \033[4mA\033[0mdd entropy to pad\n");
    printf(" \033[4mS\033[0met default pad\n");
    printf(" E\033[4mx\033[0mit\n");
-    printf("\nSelect pad (by prefix): ");
+    printf("\nSelect action: ");
    
    char input[MAX_HASH_LENGTH];
    if (!fgets(input, sizeof(input), stdin)) {
@@ -4224,7 +4278,7 @@ int handle_pads_menu(void) {
    }
    input[strcspn(input, "\n")] = 0;
    
-    // Handle actions first
+    // Handle actions
    if (toupper(input[0]) == 'G') {
        int result = handle_generate_menu();
        if (result == 0) {
@@ -4306,54 +4360,10 @@ int handle_pads_menu(void) {
        return handle_pads_menu();
    } else if (toupper(input[0]) == 'X') {
        return 0; // Exit to main menu
+    } else {
+        printf("Invalid action. Please select G, A, S, or X.\n");
+        return handle_pads_menu();
    }
-    
-    // Find matching pad by prefix
-    int selected_pad = -1;
-    for (int i = 0; i < pad_count; i++) {
-        if (strncmp(input, pads[i].chksum, strlen(input)) == 0) {
-            if (selected_pad == -1) {
-                selected_pad = i;
-            } else {
-                // Multiple matches - ambiguous
-                printf("Ambiguous prefix. Multiple matches found.\n");
-                return 1;
-            }
-        }
-    }
-    
-    if (selected_pad == -1) {
-        printf("No pad found matching prefix '%s'\n", input);
-        return 1;
-    }
-    
-    // Show selected pad actions
-    printf("\n=== Pad: %.16s... ===\n", pads[selected_pad].chksum);
-    printf("Size: %s\n", pads[selected_pad].size_str);
-    printf("Used: %s (%.1f%%)\n", pads[selected_pad].used_str, pads[selected_pad].percentage);
-    
-    printf("\nPad Actions:\n");
-    printf(" \033[4mI\033[0mnfo - Show detailed pad information\n");
-    printf(" \033[4mA\033[0mdd entropy - Enhance pad randomness\n");
-    printf(" \033[4mB\033[0mack to pad list\n");
-    printf("\nSelect action: ");
-    
-    char action[10];
-    if (!fgets(action, sizeof(action), stdin)) {
-        printf("Error: Failed to read input\n");
-        return 1;
-    }
-    
-    char action_choice = toupper(action[0]);
-    if (action_choice == 'I') {
-        return show_pad_info(pads[selected_pad].chksum);
-    } else if (action_choice == 'A') {
-        // Handle entropy addition
-        return handle_add_entropy_to_pad(pads[selected_pad].chksum);
-    }
-    
-    // Default: back to pad list (recursive call)
-    return handle_pads_menu();
 }

 void get_directory_display(const char* file_path, char* result, size_t result_size) {
@@ -4584,7 +4594,7 @@ int handle_add_entropy_to_pad(const char* pad_chksum) {
 }

 void print_usage(const char* program_name) {
-    printf("OTP Cipher - One Time Pad Implementation v1.0.0\n");
+    printf("OTP Cipher - One Time Pad Implementation v0.2.108\n");
    printf("Built for testing entropy system\n");
    printf("Usage:\n");
    printf("  %s                                         - Interactive mode\n", program_name);
--- a/test_encrypted.txt
+++ b/test_encrypted.txt
@@ -0,0 +1,8 @@
+-----BEGIN OTP MESSAGE-----
+Version: v0.2.107
+Pad-ChkSum: d0aaeb745bfbc62b1ed8c0eca4f8dc016f4fd9ed49130979f2bb25a2a3c8192e
+Pad-Offset: 1786
+
+rRK8UkPc0t5bybg=
+-----END OTP MESSAGE-----
+
Author	SHA1	Message	Date
Laan Tungir	eb126bb663	Version v0.2.109 - Simplify command line mode	2025-09-01 07:11:51 -04:00
Laan Tungir	a4a4c0d8b2	Version v0.2.108 - Fixed piping issues	2025-08-31 16:43:04 -04:00
Laan Tungir	0c4ef55a98	Version v0.2.107 - Update comments	2025-08-31 11:25:03 -04:00
Laan Tungir	4a651da067	Version v0.2.106 - Test version string replacement	2025-08-31 11:03:08 -04:00
Laan Tungir	7b5db60d80	Version v0.2.105 - Test version string replacement	2025-08-31 11:03:02 -04:00
Laan Tungir	84e2ee5639	Version v0.2.104 - Cleaned up build.sh	2025-08-31 10:43:36 -04:00
Laan Tungir	0f3af174b0	Clean up	2025-08-31 09:46:56 -04:00