`6fa4564`

source

Authored by mfwolffe <wolffemf@dukes.jmu.edu> 8 months ago

SHA: 6fa45645fb89058eab83497c5f9ec9040c303373
Parents: 56b2994
Tree: 3a0df48

12 changed files

Status	File	+
A	`src/accounts.c`	873
A	`src/config.c`	817
A	`src/display.c`	765
A	`src/error.c`	468
A	`src/git_ops.c`	682
A	`src/gpg_manager.c`	709
A	`src/main.c`	398
A	`src/main_simple.c`	132
A	`src/ssh_manager.c`	829
A	`src/stubs.c`	29
A	`src/toml_parser.c`	1064
A	`src/utils.c`	1126

src/accounts.cadded

 +/* Account management and operations with comprehensive security validation
 + * Implements secure account switching and management for gitswitch-c
 + */
++
 +#include <stdio.h>
 +#include <stdlib.h>
 +#include <string.h>
 +#include <ctype.h>
 +#include <sys/stat.h>
 +#include <unistd.h>
++
 +#include "accounts.h"
 +#include "config.h"
 +#include "display.h"
 +#include "error.h"
 +#include "utils.h"
 +#include "git_ops.h"
 +#include "ssh_manager.h"
 +#include "gpg_manager.h"
++
 +/* Internal helper functions */
 +static uint32_t get_next_available_id(const gitswitch_ctx_t *ctx);
 +static int validate_ssh_key_security(const char *ssh_key_path);
 +static int validate_gpg_key_availability(const char *gpg_key_id);
 +static int test_ssh_key_functionality(const account_t *account);
 +static int test_gpg_key_functionality(const account_t *account);
++
 +/* Initialize accounts system */
 +int accounts_init(gitswitch_ctx_t *ctx) {
 +    if (!ctx) {
 +        set_error(ERR_INVALID_ARGS, "NULL context to accounts_init");
 +        return -1;
 +    }
++
 +    /* Initialize account array */
 +    memset(ctx->accounts, 0, sizeof(ctx->accounts));
 +    ctx->account_count = 0;
 +    ctx->current_account = NULL;
++
 +    log_debug("Accounts system initialized");
 +    return 0;
 +}
++
 +/* Switch to specified account with SSH isolation and validation */
 +int accounts_switch(gitswitch_ctx_t *ctx, const char *identifier) {
 +    account_t *account;
++
 +    if (!ctx || !identifier) {
 +        set_error(ERR_INVALID_ARGS, "Invalid arguments to accounts_switch");
 +        return -1;
 +    }
++
 +    /* Find the account */
 +    account = config_find_account(ctx, identifier);
 +    if (!account) {
 +        set_error(ERR_ACCOUNT_NOT_FOUND, "Account not found: %s", identifier);
 +        return -1;
 +    }
++
 +    /* Basic validation */
 +    if (!validate_name(account->name) || !validate_email(account->email)) {
 +        set_error(ERR_ACCOUNT_INVALID, "Account has invalid name or email");
 +        return -1;
 +    }
++
 +    /* Determine git scope - use account preference or context default */
 +    git_scope_t scope = account->preferred_scope;
 +    if (scope == GIT_SCOPE_LOCAL && !git_is_repository()) {
 +        log_warning("Account prefers local scope, but not in git repository. Using global scope.");
 +        scope = GIT_SCOPE_GLOBAL;
 +    }
++
 +    /* Initialize git operations if not already done */
 +    if (git_ops_init() != 0) {
 +        set_error(ERR_GIT_CONFIG_FAILED, "Failed to initialize git operations");
 +        return -1;
 +    }
++
 +    /* If not in dry-run mode, actually set git configuration */
 +    if (!ctx->config.dry_run) {
 +        log_info("Setting git configuration for account: %s (%s scope)",
 +                 account->name, scope == GIT_SCOPE_LOCAL ? "local" : "global");
++
 +        if (git_set_config(account, scope) != 0) {
 +            set_error(ERR_GIT_CONFIG_FAILED, "Failed to set git configuration: %s",
 +                      get_last_error()->message);
 +            return -1;
 +        }
++
 +        /* Validate the configuration was set correctly */
 +        if (git_test_config(account, scope) != 0) {
 +            log_warning("Git configuration validation failed: %s", get_last_error()->message);
 +            /* Don't fail completely, just warn */
 +        }
++
 +        /* Handle SSH agent isolation if SSH is enabled */
 +        if (account->ssh_enabled && strlen(account->ssh_key_path) > 0) {
 +            log_info("Setting up SSH isolation for account: %s", account->name);
++
 +            /* Initialize SSH manager with isolated agents */
 +            ssh_config_t ssh_config = {0};
 +            if (ssh_manager_init(&ssh_config, SSH_AGENT_ISOLATED) != 0) {
 +                log_warning("Failed to initialize SSH manager: %s", get_last_error()->message);
 +            } else {
 +                /* Switch to account's SSH configuration */
 +                if (ssh_switch_account(&ssh_config, account) != 0) {
 +                    log_warning("Failed to switch SSH configuration: %s", get_last_error()->message);
 +                    /* Clean up SSH manager on failure */
 +                    ssh_manager_cleanup(&ssh_config);
 +                } else {
 +                    log_info("SSH isolation activated for account: %s", account->name);
++
 +                    /* Test SSH connection if connection testing is available */
 +                    if (strlen(account->ssh_host_alias) > 0) {
 +                        if (ssh_test_connection(account, account->ssh_host_alias) == 0) {
 +                            log_info("SSH connection test passed for %s", account->ssh_host_alias);
 +                        } else {
 +                            log_warning("SSH connection test failed for %s", account->ssh_host_alias);
 +                        }
 +                    } else {
 +                        /* Test with default GitHub host */
 +                        if (ssh_test_connection(account, "github.com") == 0) {
 +                            log_info("SSH connection test passed for github.com");
 +                        } else {
 +                            log_debug("SSH connection test failed for github.com (this may be normal)");
 +                        }
 +                    }
 +                }
 +            }
 +        }
++
 +        /* Handle GPG environment isolation if GPG is enabled */
 +        if (account->gpg_enabled && strlen(account->gpg_key_id) > 0) {
 +            log_info("Setting up GPG isolation for account: %s", account->name);
++
 +            /* Initialize GPG manager with isolated environments */
 +            gpg_config_t gpg_config = {0};
 +            if (gpg_manager_init(&gpg_config, GPG_MODE_ISOLATED) != 0) {
 +                log_warning("Failed to initialize GPG manager: %s", get_last_error()->message);
 +            } else {
 +                /* Switch to account's GPG configuration */
 +                if (gpg_switch_account(&gpg_config, account) != 0) {
 +                    log_warning("Failed to switch GPG configuration: %s", get_last_error()->message);
 +                    /* Clean up GPG manager on failure */
 +                    gpg_manager_cleanup(&gpg_config);
 +                } else {
 +                    log_info("GPG isolation activated for account: %s", account->name);
++
 +                    /* Configure git GPG signing */
 +                    if (gpg_configure_git_signing(&gpg_config, account, scope) != 0) {
 +                        log_warning("Failed to configure git GPG signing: %s", get_last_error()->message);
 +                    } else {
 +                        log_info("Git GPG signing configured for account: %s", account->name);
 +                    }
 +                }
 +            }
 +        }
 +    } else {
 +        display_info("DRY RUN: Would set git configuration for %s", account->name);
 +        if (account->ssh_enabled && strlen(account->ssh_key_path) > 0) {
 +            display_info("DRY RUN: Would activate SSH isolation for %s", account->ssh_key_path);
 +        }
 +        if (account->gpg_enabled && strlen(account->gpg_key_id) > 0) {
 +            display_info("DRY RUN: Would activate GPG isolation for key %s", account->gpg_key_id);
 +        }
 +    }
++
 +    /* Test SSH functionality if enabled (basic validation) */
 +    if (account->ssh_enabled && strlen(account->ssh_key_path) > 0) {
 +        if (test_ssh_key_functionality(account) != 0) {
 +            log_warning("SSH key test failed for account: %s", account->name);
 +        }
 +    }
++
 +    /* Test GPG functionality if enabled */
 +    if (account->gpg_enabled && strlen(account->gpg_key_id) > 0) {
 +        if (test_gpg_key_functionality(account) != 0) {
 +            log_warning("GPG key test failed for account: %s", account->name);
 +        }
 +    }
++
 +    /* Set as current account */
 +    ctx->current_account = account;
++
 +    log_info("Successfully switched to account: %s (%s)", account->name, account->description);
 +    return 0;
 +}
++
 +/* Add new account interactively with basic validation */
 +int accounts_add_interactive(gitswitch_ctx_t *ctx) {
 +    account_t new_account;
 +    char input[512];
 +    char expanded_path[MAX_PATH_LEN];
++
 +    if (!ctx) {
 +        set_error(ERR_INVALID_ARGS, "NULL context to accounts_add_interactive");
 +        return -1;
 +    }
++
 +    if (ctx->account_count >= MAX_ACCOUNTS) {
 +        set_error(ERR_ACCOUNT_EXISTS, "Maximum number of accounts reached: %d", MAX_ACCOUNTS);
 +        return -1;
 +    }
++
 +    /* Initialize new account */
 +    memset(&new_account, 0, sizeof(new_account));
 +    new_account.id = get_next_available_id(ctx);
 +    new_account.preferred_scope = ctx->config.default_scope;
++
 +    printf("\n┌─────────────────────────────────────┐\n");
 +    printf("│          Add New Account            │\n");
 +    printf("└─────────────────────────────────────┘\n\n");
++
 +    /* Get account name */
 +    do {
 +        printf("Account Name: ");
 +        fflush(stdout);
++
 +        if (!fgets(input, sizeof(input), stdin)) {
 +            set_error(ERR_FILE_IO, "Failed to read account name");
 +            return -1;
 +        }
++
 +        input[strcspn(input, "\n")] = '\0';
 +        trim_whitespace(input);
++
 +        if (!validate_name(input)) {
 +            printf("[ERROR]: Invalid name. Please enter a non-empty name.\n");
 +            continue;
 +        }
++
 +        safe_strncpy(new_account.name, input, sizeof(new_account.name));
 +        break;
 +    } while (1);
++
 +    /* Get email address */
 +    do {
 +        printf("Email Address: ");
 +        fflush(stdout);
++
 +        if (!fgets(input, sizeof(input), stdin)) {
 +            set_error(ERR_FILE_IO, "Failed to read email address");
 +            return -1;
 +        }
++
 +        input[strcspn(input, "\n")] = '\0';
 +        trim_whitespace(input);
++
 +        if (!validate_email(input)) {
 +            printf("[ERROR]: Invalid email address format.\n");
 +            continue;
 +        }
++
 +        safe_strncpy(new_account.email, input, sizeof(new_account.email));
 +        break;
 +    } while (1);
++
 +    /* Get description */
 +    printf("Description (optional): ");
 +    fflush(stdout);
++
 +    if (fgets(input, sizeof(input), stdin)) {
 +        input[strcspn(input, "\n")] = '\0';
 +        trim_whitespace(input);
++
 +        if (strlen(input) > 0) {
 +            safe_strncpy(new_account.description, input, sizeof(new_account.description));
 +        } else {
 +            safe_strncpy(new_account.description, new_account.name, sizeof(new_account.description));
 +        }
 +    } else {
 +        safe_strncpy(new_account.description, new_account.name, sizeof(new_account.description));
 +    }
++
 +    /* Get SSH key configuration */
 +    printf("SSH Key Path (optional, press Enter to skip): ");
 +    fflush(stdout);
++
 +    if (fgets(input, sizeof(input), stdin)) {
 +        input[strcspn(input, "\n")] = '\0';
 +        trim_whitespace(input);
++
 +        if (strlen(input) > 0) {
 +            /* Expand and validate path */
 +            if (expand_path(input, expanded_path, sizeof(expanded_path)) == 0) {
 +                if (path_exists(expanded_path)) {
 +                    if (validate_ssh_key_security(expanded_path) == 0) {
 +                        safe_strncpy(new_account.ssh_key_path, expanded_path, sizeof(new_account.ssh_key_path));
 +                        new_account.ssh_enabled = true;
 +                        printf("[OK]: SSH key validated: %s\n", expanded_path);
++
 +                        /* Optional SSH host alias */
 +                        printf("SSH Host Alias (optional, e.g., github.com-work): ");
 +                        fflush(stdout);
++
 +                        if (fgets(input, sizeof(input), stdin)) {
 +                            input[strcspn(input, "\n")] = '\0';
 +                            trim_whitespace(input);
++
 +                            if (strlen(input) > 0) {
 +                                safe_strncpy(new_account.ssh_host_alias, input, sizeof(new_account.ssh_host_alias));
 +                            }
 +                        }
 +                    } else {
 +                        printf("[ERROR]: SSH key validation failed. Continuing without SSH key.\n");
 +                    }
 +                } else {
 +                    printf("[ERROR]: SSH key file not found: %s\n", expanded_path);
 +                }
 +            } else {
 +                printf("[ERROR]: Invalid SSH key path: %s\n", input);
 +            }
 +        }
 +    }
++
 +    /* Get GPG key configuration */
 +    printf("GPG Key ID (optional, press Enter to skip): ");
 +    fflush(stdout);
++
 +    if (fgets(input, sizeof(input), stdin)) {
 +        input[strcspn(input, "\n")] = '\0';
 +        trim_whitespace(input);
++
 +        if (strlen(input) > 0) {
 +            if (validate_key_id(input)) {
 +                if (validate_gpg_key_availability(input) == 0) {
 +                    safe_strncpy(new_account.gpg_key_id, input, sizeof(new_account.gpg_key_id));
 +                    new_account.gpg_enabled = true;
 +                    printf("[OK]: GPG key validated: %s\n", input);
++
 +                    /* Ask about GPG signing */
 +                    printf("Enable GPG signing for commits? (y/N): ");
 +                    fflush(stdout);
++
 +                    if (fgets(input, sizeof(input), stdin)) {
 +                        input[strcspn(input, "\n")] = '\0';
 +                        trim_whitespace(input);
++
 +                        new_account.gpg_signing_enabled = (tolower(input[0]) == 'y');
 +                    }
 +                } else {
 +                    printf("[ERROR]: GPG key validation failed. Continuing without GPG key.\n");
 +                }
 +            } else {
 +                printf("[ERROR]: Invalid GPG key ID format: %s\n", input);
 +            }
 +        }
 +    }
++
 +    /* Get preferred scope */
 +    printf("Preferred Git Scope (local/global) [%s]: ",
 +           config_scope_to_string(new_account.preferred_scope));
 +    fflush(stdout);
++
 +    if (fgets(input, sizeof(input), stdin)) {
 +        input[strcspn(input, "\n")] = '\0';
 +        trim_whitespace(input);
++
 +        if (strlen(input) > 0) {
 +            new_account.preferred_scope = config_parse_scope(input);
 +        }
 +    }
++
 +    /* Basic validation */
 +    if (!validate_name(new_account.name) || !validate_email(new_account.email)) {
 +        printf("[ERROR]: Account validation failed: Invalid name or email\n");
 +        return -1;
 +    }
++
 +    /* Confirmation */
 +    printf("\nAccount Summary:\n");
 +    printf("   ID: %u\n", new_account.id);
 +    printf("   Name: %s\n", new_account.name);
 +    printf("   Email: %s\n", new_account.email);
 +    printf("   Description: %s\n", new_account.description);
 +    printf("   Scope: %s\n", config_scope_to_string(new_account.preferred_scope));
 +    printf("   SSH: %s\n", new_account.ssh_enabled ? "[ENABLED]" : "[DISABLED]");
 +    printf("   GPG: %s\n", new_account.gpg_enabled ? "[ENABLED]" : "[DISABLED]");
++
 +    printf("\nAdd this account? (y/N): ");
 +    fflush(stdout);
++
 +    if (!fgets(input, sizeof(input), stdin)) {
 +        set_error(ERR_FILE_IO, "Failed to read confirmation");
 +        return -1;
 +    }
++
 +    input[strcspn(input, "\n")] = '\0';
 +    trim_whitespace(input);
++
 +    if (tolower(input[0]) != 'y') {
 +        printf("Account creation cancelled.\n");
 +        return -1;
 +    }
++
 +    /* Add account to context */
 +    if (config_add_account(ctx, &new_account) != 0) {
 +        return -1;
 +    }
++
 +    printf("[OK]: Account added successfully!\n");
 +    return 0;
 +}
++
 +/* Remove account with confirmation and cleanup */
 +int accounts_remove(gitswitch_ctx_t *ctx, const char *identifier) {
 +    account_t *account;
 +    char input[64];
++
 +    if (!ctx || !identifier) {
 +        set_error(ERR_INVALID_ARGS, "Invalid arguments to accounts_remove");
 +        return -1;
 +    }
++
 +    /* Find the account */
 +    account = config_find_account(ctx, identifier);
 +    if (!account) {
 +        set_error(ERR_ACCOUNT_NOT_FOUND, "Account not found: %s", identifier);
 +        return -1;
 +    }
++
 +    /* Show account details */
 +    printf("\nRemove Account\n");
 +    printf("─────────────────\n");
 +    printf("ID: %u\n", account->id);
 +    printf("Name: %s\n", account->name);
 +    printf("Email: %s\n", account->email);
 +    printf("Description: %s\n", account->description);
++
 +    /* Confirmation */
 +    printf("\n[WARN]: This will permanently remove the account from configuration.\n");
 +    printf("Are you sure? (type 'yes' to confirm): ");
 +    fflush(stdout);
++
 +    if (!fgets(input, sizeof(input), stdin)) {
 +        set_error(ERR_FILE_IO, "Failed to read confirmation");
 +        return -1;
 +    }
++
 +    input[strcspn(input, "\n")] = '\0';
 +    trim_whitespace(input);
++
 +    if (strcmp(input, "yes") != 0) {
 +        printf("Account removal cancelled.\n");
 +        return 0;
 +    }
++
 +    /* Clear current account if it's the one being removed */
 +    if (ctx->current_account == account) {
 +        ctx->current_account = NULL;
 +    }
++
 +    uint32_t account_id = account->id;
++
 +    /* Remove account */
 +    if (config_remove_account(ctx, account_id) != 0) {
 +        return -1;
 +    }
++
 +    printf("[OK]: Account removed successfully.\n");
 +    return 0;
 +}
++
 +/* List all configured accounts */
 +int accounts_list(const gitswitch_ctx_t *ctx) {
 +    if (!ctx) {
 +        set_error(ERR_INVALID_ARGS, "NULL context to accounts_list");
 +        return -1;
 +    }
++
 +    if (ctx->account_count == 0) {
 +        printf("\n[INFO]: No accounts configured.\n");
 +        printf("Run 'gitswitch add' to create your first account.\n\n");
 +        return 0;
 +    }
++
 +    printf("\nConfigured Accounts (%zu total)\n", ctx->account_count);
 +    printf("════════════════════════════════════════════════════════════════\n");
++
 +    for (size_t i = 0; i < ctx->account_count; i++) {
 +        const account_t *account = &ctx->accounts[i];
 +        bool is_current = (ctx->current_account == account);
++
 +        printf("%s [%u] %s\n", is_current ? "[CURRENT]" : "", account->id, account->name);
 +        printf("     Email: %s\n", account->email);
 +        printf("     Description: %s\n", account->description);
 +        printf("     Scope: %s\n", config_scope_to_string(account->preferred_scope));
++
 +        if (account->ssh_enabled && strlen(account->ssh_key_path) > 0) {
 +            printf("     SSH Key: %s\n", account->ssh_key_path);
 +            if (strlen(account->ssh_host_alias) > 0) {
 +                printf("         Host: %s\n", account->ssh_host_alias);
 +            }
 +        } else {
 +            printf("     SSH Key: Not configured\n");
 +        }
++
 +        if (account->gpg_enabled && strlen(account->gpg_key_id) > 0) {
 +            printf("     GPG Key: %s %s\n", account->gpg_key_id,
 +                   account->gpg_signing_enabled ? "(signing enabled)" : "(signing disabled)");
 +        } else {
 +            printf("     GPG Key: Not configured\n");
 +        }
++
 +        if (i < ctx->account_count - 1) {
 +            printf("\n");
 +        }
 +    }
++
 +    printf("════════════════════════════════════════════════════════════════\n\n");
++
 +    if (ctx->current_account) {
 +        printf("Current: %s (%s)\n\n", ctx->current_account->name, ctx->current_account->description);
 +    } else {
 +        printf("No account currently active.\n\n");
 +    }
++
 +    return 0;
 +}
++
 +/* Show current account status */
 +int accounts_show_status(const gitswitch_ctx_t *ctx) {
 +    if (!ctx) {
 +        set_error(ERR_INVALID_ARGS, "NULL context to accounts_show_status");
 +        return -1;
 +    }
++
 +    printf("\nAccount Status\n");
 +    printf("════════════════\n");
++
 +    if (ctx->current_account) {
 +        const account_t *account = ctx->current_account;
++
 +        printf("Active Account: %s (ID: %u)\n", account->name, account->id);
 +        printf("Email: %s\n", account->email);
 +        printf("Description: %s\n", account->description);
 +        printf("Preferred Scope: %s\n", config_scope_to_string(account->preferred_scope));
++
 +        /* SSH Status */
 +        printf("\nSSH Configuration:\n");
 +        if (account->ssh_enabled && strlen(account->ssh_key_path) > 0) {
 +            printf("  Status: [ENABLED]\n");
 +            printf("  Key: %s\n", account->ssh_key_path);
++
 +            if (path_exists(account->ssh_key_path)) {
 +                printf("  Key File: [FOUND]\n");
++
 +                mode_t key_mode;
 +                if (get_file_permissions(account->ssh_key_path, &key_mode) == 0) {
 +                    if ((key_mode & 077) == 0) {
 +                        printf("  Permissions: [SECURE] (600)\n");
 +                    } else {
 +                        printf("  Permissions: [WARN] Insecure (%o)\n", key_mode & 0777);
 +                    }
 +                }
 +            } else {
 +                printf("  Key File: [NOT FOUND]\n");
 +            }
++
 +            if (strlen(account->ssh_host_alias) > 0) {
 +                printf("  Host Alias: %s\n", account->ssh_host_alias);
 +            }
 +        } else {
 +            printf("  Status: [DISABLED]\n");
 +        }
++
 +        /* GPG Status */
 +        printf("\nGPG Configuration:\n");
 +        if (account->gpg_enabled && strlen(account->gpg_key_id) > 0) {
 +            printf("  Status: [ENABLED]\n");
 +            printf("  Key ID: %s\n", account->gpg_key_id);
 +            printf("  Signing: %s\n", account->gpg_signing_enabled ? "[ENABLED]" : "[DISABLED]");
 +        } else {
 +            printf("  Status: [DISABLED]\n");
 +        }
++
 +        /* Git Configuration Status */
 +        printf("\nGit Configuration:\n");
 +        git_current_config_t git_config;
 +        if (git_get_current_config(&git_config) == 0) {
 +            printf("  Current Name: %s\n", git_config.name);
 +            printf("  Current Email: %s\n", git_config.email);
 +            printf("  Configuration Scope: %s\n",
 +                   git_config.scope == GIT_SCOPE_LOCAL ? "local" :
 +                   git_config.scope == GIT_SCOPE_GLOBAL ? "global" : "system");
++
 +            /* Check if git config matches account */
 +            if (strcmp(git_config.name, account->name) == 0 &&
 +                strcmp(git_config.email, account->email) == 0) {
 +                printf("  Match Status: [OK] Git config matches account\n");
 +            } else {
 +                printf("  Match Status: [WARN] Git config does not match account\n");
 +                printf("    Expected: %s <%s>\n", account->name, account->email);
 +                printf("    Current:  %s <%s>\n", git_config.name, git_config.email);
 +            }
++
 +            /* GPG signing status */
 +            if (strlen(git_config.signing_key) > 0) {
 +                printf("  GPG Signing Key: %s\n", git_config.signing_key);
 +                printf("  GPG Signing Enabled: %s\n", git_config.gpg_signing_enabled ? "[YES]" : "[NO]");
 +            } else {
 +                printf("  GPG Signing: [NOT CONFIGURED]\n");
 +            }
 +        } else {
 +            printf("  Status: [NOT FOUND] No git configuration found\n");
 +        }
++
 +        /* Repository context */
 +        printf("\nRepository Context:\n");
 +        if (git_is_repository()) {
 +            char repo_root[MAX_PATH_LEN];
 +            if (git_get_repo_root(repo_root, sizeof(repo_root)) == 0) {
 +                printf("  Repository: [FOUND] %s\n", repo_root);
 +            } else {
 +                printf("  Repository: [REPOSITORY] Current directory is a git repository\n");
 +            }
 +        } else {
 +            printf("  Repository: [NO REPOSITORY] Not in a git repository\n");
 +        }
++
 +    } else {
 +        printf("No account currently active.\n");
 +        printf("Run 'gitswitch list' to see available accounts.\n");
 +        printf("Run 'gitswitch <account>' to activate an account.\n");
++
 +        /* Show current git config even without active account */
 +        printf("\nCurrent Git Configuration:\n");
 +        git_current_config_t git_config;
 +        if (git_get_current_config(&git_config) == 0) {
 +            printf("  Name: %s\n", git_config.name);
 +            printf("  Email: %s\n", git_config.email);
 +            printf("  Scope: %s\n",
 +                   git_config.scope == GIT_SCOPE_LOCAL ? "local" :
 +                   git_config.scope == GIT_SCOPE_GLOBAL ? "global" : "system");
 +        } else {
 +            printf("  Status: [NOT FOUND] No git configuration found\n");
 +        }
++
 +        /* Repository context */
 +        printf("\nRepository Context:\n");
 +        if (git_is_repository()) {
 +            printf("  Repository: [REPOSITORY] Current directory is a git repository\n");
 +        } else {
 +            printf("  Repository: [NO REPOSITORY] Not in a git repository\n");
 +        }
 +    }
++
 +    printf("\n");
 +    return 0;
 +}
++
 +/* Simple account validation for Phase 2 */
 +int accounts_validate(const account_t *account) {
 +    if (!account) {
 +        set_error(ERR_INVALID_ARGS, "NULL account pointer");
 +        return -1;
 +    }
++
 +    /* Validate required fields */
 +    if (!validate_name(account->name)) {
 +        set_error(ERR_ACCOUNT_INVALID, "Invalid or empty account name");
 +        return -1;
 +    }
++
 +    if (!validate_email(account->email)) {
 +        set_error(ERR_ACCOUNT_INVALID, "Invalid email address format");
 +        return -1;
 +    }
++
 +    /* Basic SSH validation if enabled */
 +    if (account->ssh_enabled && strlen(account->ssh_key_path) > 0) {
 +        char expanded_path[MAX_PATH_LEN];
++
 +        if (expand_path(account->ssh_key_path, expanded_path, sizeof(expanded_path)) != 0) {
 +            set_error(ERR_ACCOUNT_INVALID, "Invalid SSH key path: %s", account->ssh_key_path);
 +            return -1;
 +        }
++
 +        if (!path_exists(expanded_path)) {
 +            set_error(ERR_ACCOUNT_INVALID, "SSH key file not found: %s", expanded_path);
 +            return -1;
 +        }
 +    }
++
 +    /* Basic GPG validation if enabled */
 +    if (account->gpg_enabled && strlen(account->gpg_key_id) > 0) {
 +        if (!validate_key_id(account->gpg_key_id)) {
 +            set_error(ERR_ACCOUNT_INVALID, "Invalid GPG key ID format: %s", account->gpg_key_id);
 +            return -1;
 +        }
 +    }
++
 +    return 0;
 +}
++
 +/* Get next available account ID */
 +static uint32_t get_next_available_id(const gitswitch_ctx_t *ctx) {
 +    uint32_t max_id = 0;
++
 +    if (!ctx) return 1;
++
 +    /* Find the highest existing ID */
 +    for (size_t i = 0; i < ctx->account_count; i++) {
 +        if (ctx->accounts[i].id > max_id) {
 +            max_id = ctx->accounts[i].id;
 +        }
 +    }
++
 +    return max_id + 1;
 +}
++
 +/* Validate SSH key security */
 +static int validate_ssh_key_security(const char *ssh_key_path) {
 +    FILE *key_file;
 +    char first_line[256];
 +    mode_t file_mode;
++
 +    if (!ssh_key_path || !path_exists(ssh_key_path)) {
 +        return -1;
 +    }
++
 +    /* Check file permissions */
 +    if (get_file_permissions(ssh_key_path, &file_mode) != 0) {
 +        return -1;
 +    }
++
 +    if ((file_mode & 077) != 0) {
 +        log_warning("SSH key file has insecure permissions: %o", file_mode & 0777);
 +        return -1;
 +    }
++
 +    /* Check if it looks like a valid SSH key */
 +    key_file = fopen(ssh_key_path, "r");
 +    if (!key_file) {
 +        return -1;
 +    }
++
 +    if (fgets(first_line, sizeof(first_line), key_file)) {
 +        /* Check for common SSH key formats */
 +        if (!string_starts_with(first_line, "-----BEGIN OPENSSH PRIVATE KEY-----") &&
 +            !string_starts_with(first_line, "-----BEGIN RSA PRIVATE KEY-----") &&
 +            !string_starts_with(first_line, "-----BEGIN DSA PRIVATE KEY-----") &&
 +            !string_starts_with(first_line, "-----BEGIN EC PRIVATE KEY-----") &&
 +            !string_starts_with(first_line, "-----BEGIN SSH2 PRIVATE KEY-----")) {
 +            fclose(key_file);
 +            log_warning("SSH key file format not recognized");
 +            return -1;
 +        }
 +    }
++
 +    fclose(key_file);
 +    return 0;
 +}
++
 +/* Validate GPG key availability */
 +static int validate_gpg_key_availability(const char *gpg_key_id) {
 +    char command[256];
 +    int result;
++
 +    if (!gpg_key_id) {
 +        return -1;
 +    }
++
 +    /* Try to find the key in the GPG keyring */
 +    if (snprintf(command, sizeof(command), "gpg --list-secret-keys %s >/dev/null 2>&1",
 +                gpg_key_id) >= sizeof(command)) {
 +        log_error("GPG command too long");
 +        return -1;
 +    }
++
 +    result = system(command);
 +    if (result != 0) {
 +        log_debug("GPG key %s not found in keyring", gpg_key_id);
 +        return -1;
 +    }
++
 +    return 0;
 +}
++
 +/* Test SSH key functionality */
 +static int test_ssh_key_functionality(const account_t *account) {
 +    /* This is a placeholder for SSH functionality testing
 +     * In a full implementation, this would:
 +     * 1. Start SSH agent if needed
 +     * 2. Load the key into agent
 +     * 3. Test connection to a known host
 +     * 4. Verify authentication works
 +     */
 +    log_debug("SSH key functionality test for %s: %s",
 +              account->name, account->ssh_key_path);
++
 +    /* For now, just validate the key file exists and has correct permissions */
 +    return validate_ssh_key_security(account->ssh_key_path);
 +}
++
 +/* Test GPG key functionality */
 +static int test_gpg_key_functionality(const account_t *account) {
 +    /* This is a placeholder for GPG functionality testing
 +     * In a full implementation, this would:
 +     * 1. Set up GPG environment
 +     * 2. Test key can be used for signing
 +     * 3. Verify key is not expired
 +     * 4. Test signing a test message
 +     */
 +    log_debug("GPG key functionality test for %s: %s",
 +              account->name, account->gpg_key_id);
++
 +    /* For now, just check if key exists in keyring */
 +    return validate_gpg_key_availability(account->gpg_key_id);
 +}
++
 +/* Run comprehensive health check on all accounts */
 +int accounts_health_check(const gitswitch_ctx_t *ctx) {
 +    bool all_healthy = true;
++
 +    if (!ctx) {
 +        set_error(ERR_INVALID_ARGS, "NULL context to accounts_health_check");
 +        return -1;
 +    }
++
 +    printf("\nAccount Health Check\n");
 +    printf("══════════════════════\n");
++
 +    if (ctx->account_count == 0) {
 +        printf("[ERROR]: No accounts configured\n");
 +        printf("   Run 'gitswitch add' to create your first account\n\n");
 +        return -1;
 +    }
++
 +    for (size_t i = 0; i < ctx->account_count; i++) {
 +        const account_t *account = &ctx->accounts[i];
 +        int validation_result = accounts_validate(account);
++
 +        printf("\n[%u] %s\n", account->id, account->name);
 +        printf("────────────────────────\n");
++
 +        if (validation_result == 0) {
 +            printf("[OK]: Account configuration valid\n");
++
 +            /* Test SSH if configured */
 +            if (account->ssh_enabled && strlen(account->ssh_key_path) > 0) {
 +                if (test_ssh_key_functionality(account) == 0) {
 +                    printf("[OK]: SSH key functional\n");
 +                } else {
 +                    printf("[ERROR]: SSH key issues detected\n");
 +                    all_healthy = false;
 +                }
 +            }
++
 +            /* Test GPG if configured */
 +            if (account->gpg_enabled && strlen(account->gpg_key_id) > 0) {
 +                if (test_gpg_key_functionality(account) == 0) {
 +                    printf("[OK]: GPG key functional\n");
 +                } else {
 +                    printf("[ERROR]: GPG key issues detected\n");
 +                    all_healthy = false;
 +                }
 +            }
 +        } else {
 +            printf("[ERROR]: Account validation failed\n");
 +            all_healthy = false;
 +        }
 +    }
++
 +    printf("\n══════════════════════\n");
 +    if (all_healthy) {
 +        printf("[OK]: All accounts are healthy\n\n");
 +        return 0;
 +    } else {
 +        printf("[ERROR]: Some accounts have issues\n\n");
 +        return -1;
 +    }
 +}

src/config.cadded

 +/* Configuration file management with comprehensive security validation
 + * Implements secure TOML-based configuration for gitswitch-c
 + */
++
 +#include <stdio.h>
 +#include <stdlib.h>
 +#include <string.h>
 +#include <sys/stat.h>
 +#include <time.h>
 +#include <unistd.h>
++
 +#include "config.h"
 +#include "toml_parser.h"
 +#include "error.h"
 +#include "utils.h"
++
 +/* Default configuration template with security-focused defaults */
 +const char *default_config_template =
 +"# gitswitch-c Configuration File\n"
 +"# This file contains sensitive information - ensure proper permissions (600)\n"
 +"\n"
 +"[settings]\n"
 +"# Default scope for git configuration changes\n"
 +"# Options: \"local\" (repository-specific) or \"global\" (user-wide)\n"
 +"default_scope = \"local\"\n"
 +"\n"
 +"# Example account configuration\n"
 +"# Uncomment and modify for your accounts\n"
 +"\n"
 +"#[accounts.1]\n"
 +"#name = \"Your Name\"\n"
 +"#email = \"your.email@example.com\"\n"
 +"#description = \"Personal Account\"\n"
 +"#preferred_scope = \"local\"\n"
 +"#ssh_key = \"~/.ssh/id_ed25519_personal\"\n"
 +"#gpg_key = \"1234567890ABCDEF\"\n"
 +"#gpg_signing_enabled = true\n"
 +"\n"
 +"#[accounts.2]\n"
 +"#name = \"Your Name\"\n"
 +"#email = \"work@company.com\"\n"
 +"#description = \"Work Account\"\n"
 +"#preferred_scope = \"global\"\n"
 +"#ssh_key = \"~/.ssh/id_rsa_work\"\n"
 +"#gpg_key = \"ABCDEF1234567890\"\n"
 +"#gpg_signing_enabled = true\n"
 +"#ssh_host = \"github.com-work\"\n"
 +"\n"
 +"# Security Notes:\n"
 +"# - SSH keys should have 600 permissions\n"
 +"# - GPG keys should exist in your keyring\n"
 +"# - This config file should have 600 permissions\n"
 +"# - Use absolute paths or ~ expansion for key files\n";
++
 +/* Internal helper functions */
 +static int validate_config_file_security(const char *config_path);
 +static int create_config_directory_secure(const char *config_dir);
 +static int load_accounts_from_toml(gitswitch_ctx_t *ctx, const toml_document_t *doc);
 +static int save_accounts_to_toml(const gitswitch_ctx_t *ctx, toml_document_t *doc);
 +static int parse_account_id_from_section(const char *section_name, uint32_t *account_id);
 +static int validate_account_security(const account_t *account);
++
 +/* Initialize configuration system */
 +int config_init(gitswitch_ctx_t *ctx) {
 +    char config_path[MAX_PATH_LEN];
 +    char config_dir[MAX_PATH_LEN];
++
 +    if (!ctx) {
 +        set_error(ERR_INVALID_ARGS, "NULL context to config_init");
 +        return -1;
 +    }
++
 +    /* Initialize context */
 +    memset(ctx, 0, sizeof(gitswitch_ctx_t));
 +    ctx->config.default_scope = GIT_SCOPE_LOCAL;
 +    ctx->config.verbose = false;
 +    ctx->config.dry_run = false;
 +    ctx->config.color_output = true;
++
 +    /* Get configuration directory path */
 +    if (get_config_directory(config_dir, sizeof(config_dir)) != 0) {
 +        return -1;
 +    }
++
 +    /* Ensure config directory exists with secure permissions */
 +    if (create_config_directory_secure(config_dir) != 0) {
 +        return -1;
 +    }
++
 +    /* Build config file path */
 +    if (join_path(config_path, sizeof(config_path), config_dir, DEFAULT_CONFIG_FILE) != 0) {
 +        return -1;
 +    }
++
 +    /* Store config path in context */
 +    safe_strncpy(ctx->config.config_path, config_path, sizeof(ctx->config.config_path));
++
 +    /* Load configuration if it exists */
 +    if (path_exists(config_path)) {
 +        log_info("Loading configuration from: %s", config_path);
 +        return config_load(ctx, config_path);
 +    } else {
 +        log_info("Configuration file not found, will create default");
 +        /* Don't automatically create - let user create when needed */
 +        return 0;
 +    }
 +}
++
 +/* Load configuration from TOML file */
 +int config_load(gitswitch_ctx_t *ctx, const char *config_path) {
 +    toml_document_t toml_doc;
 +    char scope_str[32];
++
 +    if (!ctx || !config_path) {
 +        set_error(ERR_INVALID_ARGS, "Invalid arguments to config_load");
 +        return -1;
 +    }
++
 +    /* Validate file security before loading */
 +    if (validate_config_file_security(config_path) != 0) {
 +        return -1;
 +    }
++
 +    /* Parse TOML configuration */
 +    toml_init_document(&toml_doc);
 +    if (toml_parse_file(config_path, &toml_doc) != 0) {
 +        toml_cleanup_document(&toml_doc);
 +        return -1;
 +    }
++
 +    /* Load settings section */
 +    if (toml_get_string(&toml_doc, "settings", "default_scope",
 +                        scope_str, sizeof(scope_str)) == 0) {
 +        ctx->config.default_scope = config_parse_scope(scope_str);
 +    } else {
 +        log_warning("No default_scope found in settings, using local");
 +        ctx->config.default_scope = GIT_SCOPE_LOCAL;
 +    }
++
 +    /* Load accounts */
 +    if (load_accounts_from_toml(ctx, &toml_doc) != 0) {
 +        toml_cleanup_document(&toml_doc);
 +        return -1;
 +    }
++
 +    /* Store config path */
 +    safe_strncpy(ctx->config.config_path, config_path, sizeof(ctx->config.config_path));
++
 +    toml_cleanup_document(&toml_doc);
++
 +    log_info("Configuration loaded successfully: %zu accounts", ctx->account_count);
 +    return 0;
 +}
++
 +/* Save configuration to TOML file */
 +int config_save(const gitswitch_ctx_t *ctx, const char *config_path) {
 +    toml_document_t toml_doc;
 +    char temp_path[MAX_PATH_LEN];
 +    int result = -1;
++
 +    if (!ctx || !config_path) {
 +        set_error(ERR_INVALID_ARGS, "Invalid arguments to config_save");
 +        return -1;
 +    }
++
 +    /* Create backup if file exists */
 +    if (path_exists(config_path)) {
 +        if (config_backup(config_path) != 0) {
 +            log_warning("Failed to create backup before saving config");
 +        }
 +    }
++
 +    /* Create temporary file path for atomic write */
 +    if (snprintf(temp_path, sizeof(temp_path), "%s.tmp", config_path) >= sizeof(temp_path)) {
 +        set_error(ERR_INVALID_ARGS, "Temporary file path too long");
 +        return -1;
 +    }
++
 +    /* Initialize TOML document */
 +    toml_init_document(&toml_doc);
++
 +    /* Add settings section */
 +    if (toml_set_string(&toml_doc, "settings", "default_scope",
 +                        config_scope_to_string(ctx->config.default_scope)) != 0) {
 +        goto cleanup;
 +    }
++
 +    /* Add accounts */
 +    if (save_accounts_to_toml(ctx, &toml_doc) != 0) {
 +        goto cleanup;
 +    }
++
 +    /* Write to temporary file first */
 +    if (toml_write_file(&toml_doc, temp_path) != 0) {
 +        goto cleanup;
 +    }
++
 +    /* Set secure permissions on temp file */
 +    if (set_file_permissions(temp_path, PERM_USER_RW) != 0) {
 +        unlink(temp_path);
 +        goto cleanup;
 +    }
++
 +    /* Atomic move from temp to final location */
 +    if (rename(temp_path, config_path) != 0) {
 +        set_system_error(ERR_CONFIG_WRITE_FAILED,
 +                        "Failed to move temporary config file to final location");
 +        unlink(temp_path);
 +        goto cleanup;
 +    }
++
 +    log_info("Configuration saved successfully to: %s", config_path);
 +    result = 0;
++
 +cleanup:
 +    toml_cleanup_document(&toml_doc);
 +    return result;
 +}
++
 +/* Create default configuration file */
 +int config_create_default(const char *config_path) {
 +    FILE *file;
 +    char config_dir[MAX_PATH_LEN];
 +    char *last_slash;
++
 +    if (!config_path) {
 +        set_error(ERR_INVALID_ARGS, "NULL config path to config_create_default");
 +        return -1;
 +    }
++
 +    /* Extract directory from config path */
 +    safe_strncpy(config_dir, config_path, sizeof(config_dir));
 +    last_slash = strrchr(config_dir, '/');
 +    if (last_slash) {
 +        *last_slash = '\0';
 +    }
++
 +    /* Ensure directory exists */
 +    if (create_config_directory_secure(config_dir) != 0) {
 +        return -1;
 +    }
++
 +    /* Create file with secure permissions */
 +    file = fopen(config_path, "w");
 +    if (!file) {
 +        set_system_error(ERR_CONFIG_WRITE_FAILED, "Failed to create config file: %s", config_path);
 +        return -1;
 +    }
++
 +    /* Write default template */
 +    if (fwrite(default_config_template, 1, strlen(default_config_template), file) !=
 +        strlen(default_config_template)) {
 +        set_system_error(ERR_CONFIG_WRITE_FAILED, "Failed to write default config content");
 +        fclose(file);
 +        return -1;
 +    }
++
 +    fclose(file);
++
 +    /* Set secure permissions */
 +    if (set_file_permissions(config_path, PERM_USER_RW) != 0) {
 +        return -1;
 +    }
++
 +    log_info("Created default configuration file: %s", config_path);
 +    return 0;
 +}
++
 +/* Validate configuration structure */
 +int config_validate(const gitswitch_ctx_t *ctx) {
 +    if (!ctx) {
 +        set_error(ERR_INVALID_ARGS, "NULL context to config_validate");
 +        return -1;
 +    }
++
 +    /* Validate configuration file security */
 +    if (path_exists(ctx->config.config_path)) {
 +        if (validate_config_file_security(ctx->config.config_path) != 0) {
 +            return -1;
 +        }
 +    }
++
 +    /* Validate each account */
 +    for (size_t i = 0; i < ctx->account_count; i++) {
 +        if (validate_account_security(&ctx->accounts[i]) != 0) {
 +            set_error(ERR_ACCOUNT_INVALID, "Account %u failed security validation",
 +                      ctx->accounts[i].id);
 +            return -1;
 +        }
 +    }
++
 +    log_debug("Configuration validation passed for %zu accounts", ctx->account_count);
 +    return 0;
 +}
++
 +/* Get configuration file path */
 +int config_get_path(char *path_buffer, size_t buffer_size) {
 +    char config_dir[MAX_PATH_LEN];
++
 +    if (!path_buffer || buffer_size == 0) {
 +        set_error(ERR_INVALID_ARGS, "Invalid arguments to config_get_path");
 +        return -1;
 +    }
++
 +    /* Get config directory */
 +    if (get_config_directory(config_dir, sizeof(config_dir)) != 0) {
 +        return -1;
 +    }
++
 +    /* Build full path */
 +    return join_path(path_buffer, buffer_size, config_dir, DEFAULT_CONFIG_FILE);
 +}
++
 +/* Add new account to configuration */
 +int config_add_account(gitswitch_ctx_t *ctx, const account_t *account) {
 +    if (!ctx || !account) {
 +        set_error(ERR_INVALID_ARGS, "Invalid arguments to config_add_account");
 +        return -1;
 +    }
++
 +    if (ctx->account_count >= MAX_ACCOUNTS) {
 +        set_error(ERR_ACCOUNT_EXISTS, "Maximum number of accounts reached: %d", MAX_ACCOUNTS);
 +        return -1;
 +    }
++
 +    /* Validate account security */
 +    if (validate_account_security(account) != 0) {
 +        return -1;
 +    }
++
 +    /* Check for duplicate IDs */
 +    for (size_t i = 0; i < ctx->account_count; i++) {
 +        if (ctx->accounts[i].id == account->id) {
 +            set_error(ERR_ACCOUNT_EXISTS, "Account with ID %u already exists", account->id);
 +            return -1;
 +        }
 +    }
++
 +    /* Add account */
 +    ctx->accounts[ctx->account_count] = *account;
 +    ctx->account_count++;
++
 +    log_info("Added account: %s (%s)", account->name, account->description);
 +    return 0;
 +}
++
 +/* Remove account from configuration */
 +int config_remove_account(gitswitch_ctx_t *ctx, uint32_t account_id) {
 +    size_t found_index = SIZE_MAX;
++
 +    if (!ctx) {
 +        set_error(ERR_INVALID_ARGS, "NULL context to config_remove_account");
 +        return -1;
 +    }
++
 +    /* Find account */
 +    for (size_t i = 0; i < ctx->account_count; i++) {
 +        if (ctx->accounts[i].id == account_id) {
 +            found_index = i;
 +            break;
 +        }
 +    }
++
 +    if (found_index == SIZE_MAX) {
 +        set_error(ERR_ACCOUNT_NOT_FOUND, "Account with ID %u not found", account_id);
 +        return -1;
 +    }
++
 +    /* Clear sensitive data before removing */
 +    secure_zero_memory(&ctx->accounts[found_index], sizeof(account_t));
++
 +    /* Shift remaining accounts */
 +    for (size_t i = found_index; i < ctx->account_count - 1; i++) {
 +        ctx->accounts[i] = ctx->accounts[i + 1];
 +    }
++
 +    ctx->account_count--;
++
 +    /* Clear the last slot */
 +    memset(&ctx->accounts[ctx->account_count], 0, sizeof(account_t));
++
 +    log_info("Removed account with ID: %u", account_id);
 +    return 0;
 +}
++
 +/* Update existing account */
 +int config_update_account(gitswitch_ctx_t *ctx, const account_t *account) {
 +    account_t *existing_account = NULL;
++
 +    if (!ctx || !account) {
 +        set_error(ERR_INVALID_ARGS, "Invalid arguments to config_update_account");
 +        return -1;
 +    }
++
 +    /* Find existing account */
 +    for (size_t i = 0; i < ctx->account_count; i++) {
 +        if (ctx->accounts[i].id == account->id) {
 +            existing_account = &ctx->accounts[i];
 +            break;
 +        }
 +    }
++
 +    if (!existing_account) {
 +        set_error(ERR_ACCOUNT_NOT_FOUND, "Account with ID %u not found", account->id);
 +        return -1;
 +    }
++
 +    /* Validate new account data */
 +    if (validate_account_security(account) != 0) {
 +        return -1;
 +    }
++
 +    /* Clear old sensitive data */
 +    secure_zero_memory(existing_account, sizeof(account_t));
++
 +    /* Update with new data */
 +    *existing_account = *account;
++
 +    log_info("Updated account: %s (%s)", account->name, account->description);
 +    return 0;
 +}
++
 +/* Find account by ID or name/description */
 +account_t *config_find_account(gitswitch_ctx_t *ctx, const char *identifier) {
 +    char *endptr;
 +    unsigned long account_id;
++
 +    if (!ctx || !identifier) {
 +        set_error(ERR_INVALID_ARGS, "Invalid arguments to config_find_account");
 +        return NULL;
 +    }
++
 +    /* Try to parse as numeric ID */
 +    account_id = strtoul(identifier, &endptr, 10);
 +    if (*endptr == '\0') {
 +        /* It's a number - search by ID */
 +        for (size_t i = 0; i < ctx->account_count; i++) {
 +            if (ctx->accounts[i].id == (uint32_t)account_id) {
 +                return &ctx->accounts[i];
 +            }
 +        }
 +    } else {
 +        /* Search by name, email, or description */
 +        for (size_t i = 0; i < ctx->account_count; i++) {
 +            if (strstr(ctx->accounts[i].name, identifier) ||
 +                strstr(ctx->accounts[i].description, identifier) ||
 +                strcmp(ctx->accounts[i].email, identifier) == 0) {
 +                return &ctx->accounts[i];
 +            }
 +        }
 +    }
++
 +    return NULL;
 +}
++
 +/* Parse git scope from string */
 +git_scope_t config_parse_scope(const char *scope_str) {
 +    if (!scope_str) return GIT_SCOPE_LOCAL;
++
 +    if (strcmp(scope_str, "global") == 0) {
 +        return GIT_SCOPE_GLOBAL;
 +    } else if (strcmp(scope_str, "system") == 0) {
 +        return GIT_SCOPE_SYSTEM;
 +    } else {
 +        return GIT_SCOPE_LOCAL;
 +    }
 +}
++
 +/* Convert git scope to string */
 +const char *config_scope_to_string(git_scope_t scope) {
 +    switch (scope) {
 +        case GIT_SCOPE_GLOBAL: return "global";
 +        case GIT_SCOPE_SYSTEM: return "system";
 +        case GIT_SCOPE_LOCAL:
 +        default:
 +            return "local";
 +    }
 +}
++
 +/* Backup configuration file with timestamp */
 +int config_backup(const char *config_path) {
 +    char backup_path[MAX_PATH_LEN];
 +    char timestamp[32];
 +    time_t now;
 +    struct tm *tm_info;
++
 +    if (!config_path) {
 +        set_error(ERR_INVALID_ARGS, "NULL config path to config_backup");
 +        return -1;
 +    }
++
 +    if (!path_exists(config_path)) {
 +        log_debug("Config file does not exist, no backup needed");
 +        return 0;
 +    }
++
 +    /* Generate timestamp */
 +    time(&now);
 +    tm_info = localtime(&now);
 +    if (tm_info) {
 +        strftime(timestamp, sizeof(timestamp), "%Y%m%d_%H%M%S", tm_info);
 +    } else {
 +        snprintf(timestamp, sizeof(timestamp), "%ld", (long)now);
 +    }
++
 +    /* Create backup path */
 +    if (snprintf(backup_path, sizeof(backup_path), "%s.backup.%s",
 +                config_path, timestamp) >= sizeof(backup_path)) {
 +        set_error(ERR_INVALID_ARGS, "Backup path too long");
 +        return -1;
 +    }
++
 +    /* Copy file */
 +    if (copy_file(config_path, backup_path) != 0) {
 +        return -1;
 +    }
++
 +    /* Set secure permissions on backup */
 +    if (set_file_permissions(backup_path, PERM_USER_RW) != 0) {
 +        return -1;
 +    }
++
 +    log_info("Created configuration backup: %s", backup_path);
 +    return 0;
 +}
++
 +/* Internal helper functions implementation */
++
 +/* Validate configuration file security */
 +static int validate_config_file_security(const char *config_path) {
 +    struct stat file_stat;
++
 +    if (stat(config_path, &file_stat) != 0) {
 +        set_system_error(ERR_CONFIG_NOT_FOUND, "Cannot access config file: %s", config_path);
 +        return -1;
 +    }
++
 +    /* Check file permissions - must not be readable by group/others */
 +    if (file_stat.st_mode & (S_IRGRP | S_IROTH | S_IWGRP | S_IWOTH)) {
 +        set_error(ERR_PERMISSION_DENIED,
 +                  "Configuration file has unsafe permissions: %o (should be 600)",
 +                  file_stat.st_mode & 0777);
 +        return -1;
 +    }
++
 +    /* Check ownership - must be owned by current user */
 +    if (file_stat.st_uid != getuid()) {
 +        set_error(ERR_PERMISSION_DENIED, "Configuration file not owned by current user");
 +        return -1;
 +    }
++
 +    /* Check file size is reasonable */
 +    if (file_stat.st_size > TOML_MAX_FILE_SIZE) {
 +        set_error(ERR_CONFIG_INVALID, "Configuration file too large: %ld bytes", file_stat.st_size);
 +        return -1;
 +    }
++
 +    return 0;
 +}
++
 +/* Create config directory with secure permissions */
 +static int create_config_directory_secure(const char *config_dir) {
 +    if (!path_exists(config_dir)) {
 +        if (create_directory_recursive(config_dir, PERM_USER_RWX) != 0) {
 +            return -1;
 +        }
 +        log_info("Created configuration directory: %s", config_dir);
 +    }
++
 +    /* Verify directory permissions */
 +    mode_t dir_mode;
 +    if (get_file_permissions(config_dir, &dir_mode) == 0) {
 +        if ((dir_mode & 077) != 0) {
 +            /* Directory has group/other permissions - fix it */
 +            if (set_file_permissions(config_dir, PERM_USER_RWX) != 0) {
 +                return -1;
 +            }
 +            log_warning("Fixed configuration directory permissions");
 +        }
 +    }
++
 +    return 0;
 +}
++
 +/* Load accounts from TOML document */
 +static int load_accounts_from_toml(gitswitch_ctx_t *ctx, const toml_document_t *doc) {
 +    char sections[TOML_MAX_SECTIONS][TOML_MAX_SECTION_LEN];
 +    size_t section_count;
++
 +    if (toml_get_sections(doc, sections, TOML_MAX_SECTIONS, &section_count) != 0) {
 +        set_error(ERR_CONFIG_INVALID, "Failed to get sections from TOML document");
 +        return -1;
 +    }
++
 +    ctx->account_count = 0;
++
 +    for (size_t i = 0; i < section_count; i++) {
 +        if (string_starts_with(sections[i], "accounts.")) {
 +            account_t account;
 +            uint32_t account_id;
 +            char temp_str[256];
 +            bool temp_bool;
++
 +            /* Parse account ID from section name */
 +            if (parse_account_id_from_section(sections[i], &account_id) != 0) {
 +                log_warning("Invalid account section name: %s", sections[i]);
 +                continue;
 +            }
++
 +            /* Initialize account */
 +            memset(&account, 0, sizeof(account));
 +            account.id = account_id;
 +            account.preferred_scope = GIT_SCOPE_LOCAL; /* Default */
++
 +            /* Load required fields */
 +            if (toml_get_string(doc, sections[i], "name", account.name, sizeof(account.name)) != 0) {
 +                log_error("Account %u missing required 'name' field", account_id);
 +                continue;
 +            }
++
 +            if (toml_get_string(doc, sections[i], "email", account.email, sizeof(account.email)) != 0) {
 +                log_error("Account %u missing required 'email' field", account_id);
 +                continue;
 +            }
++
 +            /* Load optional fields */
 +            if (toml_get_string(doc, sections[i], "description",
 +                               account.description, sizeof(account.description)) != 0) {
 +                /* Use name as description if not provided */
 +                safe_strncpy(account.description, account.name, sizeof(account.description));
 +            }
++
 +            if (toml_get_string(doc, sections[i], "preferred_scope", temp_str, sizeof(temp_str)) == 0) {
 +                account.preferred_scope = config_parse_scope(temp_str);
 +            }
++
 +            /* SSH configuration */
 +            if (toml_get_string(doc, sections[i], "ssh_key",
 +                               account.ssh_key_path, sizeof(account.ssh_key_path)) == 0 &&
 +                strlen(account.ssh_key_path) > 0) {
 +                account.ssh_enabled = true;
++
 +                /* Expand path if needed */
 +                char expanded_path[MAX_PATH_LEN];
 +                if (expand_path(account.ssh_key_path, expanded_path, sizeof(expanded_path)) == 0) {
 +                    safe_strncpy(account.ssh_key_path, expanded_path, sizeof(account.ssh_key_path));
 +                }
++
 +                /* Optional SSH host alias */
 +                toml_get_string(doc, sections[i], "ssh_host",
 +                               account.ssh_host_alias, sizeof(account.ssh_host_alias));
 +            }
++
 +            /* GPG configuration */
 +            if (toml_get_string(doc, sections[i], "gpg_key",
 +                               account.gpg_key_id, sizeof(account.gpg_key_id)) == 0 &&
 +                strlen(account.gpg_key_id) > 0) {
 +                account.gpg_enabled = true;
++
 +                /* GPG signing preference */
 +                if (toml_get_boolean(doc, sections[i], "gpg_signing_enabled", &temp_bool) == 0) {
 +                    account.gpg_signing_enabled = temp_bool;
 +                }
 +            }
++
 +            /* Validate and add account */
 +            if (validate_account_security(&account) == 0) {
 +                if (ctx->account_count < MAX_ACCOUNTS) {
 +                    ctx->accounts[ctx->account_count] = account;
 +                    ctx->account_count++;
 +                    log_debug("Loaded account: %s (%s)", account.name, account.description);
 +                } else {
 +                    log_error("Too many accounts, skipping account %u", account_id);
 +                }
 +            } else {
 +                log_error("Account %u failed security validation", account_id);
 +            }
 +        }
 +    }
++
 +    log_info("Loaded %zu accounts from configuration", ctx->account_count);
 +    return 0;
 +}
++
 +/* Parse account ID from section name like "accounts.1" */
 +static int parse_account_id_from_section(const char *section_name, uint32_t *account_id) {
 +    const char *dot_pos;
 +    char *endptr;
 +    unsigned long parsed_id;
++
 +    if (!section_name || !account_id) return -1;
++
 +    dot_pos = strchr(section_name, '.');
 +    if (!dot_pos || dot_pos == section_name + strlen(section_name) - 1) {
 +        return -1;
 +    }
++
 +    parsed_id = strtoul(dot_pos + 1, &endptr, 10);
 +    if (*endptr != '\0' || parsed_id == 0 || parsed_id > UINT32_MAX) {
 +        return -1;
 +    }
++
 +    *account_id = (uint32_t)parsed_id;
 +    return 0;
 +}
++
 +/* Validate account security */
 +static int validate_account_security(const account_t *account) {
 +    char expanded_path[MAX_PATH_LEN];
 +    mode_t file_mode;
++
 +    if (!account) {
 +        set_error(ERR_INVALID_ARGS, "NULL account to validate");
 +        return -1;
 +    }
++
 +    /* Validate required fields */
 +    if (!validate_name(account->name)) {
 +        set_error(ERR_ACCOUNT_INVALID, "Invalid account name: %s", account->name);
 +        return -1;
 +    }
++
 +    if (!validate_email(account->email)) {
 +        set_error(ERR_ACCOUNT_INVALID, "Invalid email address: %s", account->email);
 +        return -1;
 +    }
++
 +    /* Validate SSH key if configured */
 +    if (account->ssh_enabled && strlen(account->ssh_key_path) > 0) {
 +        if (expand_path(account->ssh_key_path, expanded_path, sizeof(expanded_path)) != 0) {
 +            set_error(ERR_ACCOUNT_INVALID, "Invalid SSH key path: %s", account->ssh_key_path);
 +            return -1;
 +        }
++
 +        if (!path_exists(expanded_path)) {
 +            set_error(ERR_ACCOUNT_INVALID, "SSH key file not found: %s", expanded_path);
 +            return -1;
 +        }
++
 +        /* Check SSH key file permissions - must be 600 */
 +        if (get_file_permissions(expanded_path, &file_mode) == 0) {
 +            if ((file_mode & 077) != 0) {
 +                set_error(ERR_ACCOUNT_INVALID,
 +                          "SSH key file has unsafe permissions: %o (should be 600)",
 +                          file_mode & 0777);
 +                return -1;
 +            }
 +        }
 +    }
++
 +    /* Validate GPG key if configured */
 +    if (account->gpg_enabled && strlen(account->gpg_key_id) > 0) {
 +        if (!validate_key_id(account->gpg_key_id)) {
 +            set_error(ERR_ACCOUNT_INVALID, "Invalid GPG key ID: %s", account->gpg_key_id);
 +            return -1;
 +        }
 +    }
++
 +    return 0;
 +}
++
 +/* Save accounts to TOML document */
 +static int save_accounts_to_toml(const gitswitch_ctx_t *ctx, toml_document_t *doc) {
 +    char section_name[64];
++
 +    if (!ctx || !doc) {
 +        set_error(ERR_INVALID_ARGS, "Invalid arguments to save_accounts_to_toml");
 +        return -1;
 +    }
++
 +    /* Save each account */
 +    for (size_t i = 0; i < ctx->account_count; i++) {
 +        const account_t *account = &ctx->accounts[i];
++
 +        /* Create section name */
 +        if (snprintf(section_name, sizeof(section_name), "accounts.%u", account->id) >= sizeof(section_name)) {
 +            set_error(ERR_ACCOUNT_INVALID, "Account ID too large: %u", account->id);
 +            return -1;
 +        }
++
 +        /* Save required fields */
 +        if (toml_set_string(doc, section_name, "name", account->name) != 0) {
 +            set_error(ERR_CONFIG_INVALID, "Failed to save account name");
 +            return -1;
 +        }
++
 +        if (toml_set_string(doc, section_name, "email", account->email) != 0) {
 +            set_error(ERR_CONFIG_INVALID, "Failed to save account email");
 +            return -1;
 +        }
++
 +        /* Save optional fields */
 +        if (strlen(account->description) > 0) {
 +            toml_set_string(doc, section_name, "description", account->description);
 +        }
++
 +        toml_set_string(doc, section_name, "preferred_scope",
 +                       config_scope_to_string(account->preferred_scope));
++
 +        /* Save SSH configuration */
 +        if (account->ssh_enabled && strlen(account->ssh_key_path) > 0) {
 +            toml_set_string(doc, section_name, "ssh_key", account->ssh_key_path);
++
 +            if (strlen(account->ssh_host_alias) > 0) {
 +                toml_set_string(doc, section_name, "ssh_host", account->ssh_host_alias);
 +            }
 +        }
++
 +        /* Save GPG configuration */
 +        if (account->gpg_enabled && strlen(account->gpg_key_id) > 0) {
 +            toml_set_string(doc, section_name, "gpg_key", account->gpg_key_id);
 +            toml_set_boolean(doc, section_name, "gpg_signing_enabled", account->gpg_signing_enabled);
 +        }
 +    }
++
 +    return 0;
 +}

src/display.cadded

 +/* Display and user interface functions
 + * Provides safe, accessible terminal output for gitswitch-c
 + */
++
 +#include <stdio.h>
 +#include <stdlib.h>
 +#include <string.h>
 +#include <stdarg.h>
 +#include <unistd.h>
 +#include <ctype.h>
 +#include <termios.h>
++
 +#include "display.h"
 +#include "utils.h"
 +#include "error.h"
 +#include "git_ops.h"
++
 +/* Global display state */
 +static bool g_color_enabled = false;
 +static bool g_color_forced = false;
 +static int g_terminal_width = 80;
 +static int g_terminal_height = 24;
++
 +/* Color support detection */
 +static bool detect_color_support(void) {
 +    const char *term = getenv("TERM");
 +    const char *colorterm = getenv("COLORTERM");
++
 +    /* Force color if COLORTERM is set */
 +    if (colorterm && *colorterm) {
 +        return true;
 +    }
++
 +    /* Check for common color-capable terminals */
 +    if (term) {
 +        if (strstr(term, "color") ||
 +            strstr(term, "xterm") ||
 +            strstr(term, "screen") ||
 +            strstr(term, "tmux") ||
 +            strcmp(term, "linux") == 0) {
 +            return true;
 +        }
 +    }
++
 +    return false;
 +}
++
 +/* Initialize display system */
 +int display_init(bool force_color, bool no_color) {
 +    if (no_color) {
 +        g_color_enabled = false;
 +        g_color_forced = true;
 +    } else if (force_color) {
 +        g_color_enabled = true;
 +        g_color_forced = true;
 +    } else {
 +        /* Auto-detect color support */
 +        g_color_enabled = is_terminal(STDOUT_FILENO) && detect_color_support();
 +        g_color_forced = false;
 +    }
++
 +    /* Get terminal size */
 +    if (get_terminal_size(&g_terminal_width, &g_terminal_height) != 0) {
 +        /* Use defaults if we can't get size */
 +        g_terminal_width = 80;
 +        g_terminal_height = 24;
 +    }
++
 +    log_debug("Display initialized: color=%s, size=%dx%d",
 +              g_color_enabled ? "enabled" : "disabled",
 +              g_terminal_width, g_terminal_height);
++
 +    return 0;
 +}
++
 +/* Check if terminal supports color output */
 +bool display_supports_color(void) {
 +    return g_color_enabled;
 +}
++
 +/* Format and colorize text based on content type */
 +const char *display_colorize(const char *text, const char *type) {
 +    static char colored_buffer[512];
 +    const char *color_code = "";
++
 +    if (!g_color_enabled || !text || !type) {
 +        return text;
 +    }
++
 +    /* Select color based on type */
 +    if (strcmp(type, "success") == 0) {
 +        color_code = COLOR_GREEN;
 +    } else if (strcmp(type, "error") == 0) {
 +        color_code = COLOR_RED;
 +    } else if (strcmp(type, "warning") == 0) {
 +        color_code = COLOR_YELLOW;
 +    } else if (strcmp(type, "info") == 0) {
 +        color_code = COLOR_BLUE;
 +    } else if (strcmp(type, "header") == 0) {
 +        color_code = COLOR_BOLD COLOR_CYAN;
 +    } else if (strcmp(type, "current") == 0) {
 +        color_code = COLOR_BOLD COLOR_GREEN;
 +    } else if (strcmp(type, "inactive") == 0) {
 +        color_code = COLOR_DIM;
 +    } else {
 +        return text; /* No coloring */
 +    }
++
 +    snprintf(colored_buffer, sizeof(colored_buffer),
 +             "%s%s%s", color_code, text, COLOR_RESET);
++
 +    return colored_buffer;
 +}
++
 +/* Print formatted header with decorative border */
 +void display_header(const char *title) {
 +    int title_len, padding, total_width;
 +    int i;
++
 +    if (!title) return;
++
 +    title_len = strlen(title);
 +    total_width = (title_len + 4 > 40) ? title_len + 4 : 40;
 +    if (total_width > g_terminal_width - 2) {
 +        total_width = g_terminal_width - 2;
 +    }
++
 +    padding = (total_width - title_len - 2) / 2;
++
 +    /* Top border */
 +    printf("┌");
 +    for (i = 0; i < total_width - 2; i++) {
 +        printf("─");
 +    }
 +    printf("┐\n");
++
 +    /* Title line */
 +    printf("│%s%*s%s%s%*s│\n",
 +           display_colorize("", "header"),
 +           padding, "",
 +           display_colorize(title, "header"),
 +           COLOR_RESET,
 +           total_width - title_len - padding - 2, "");
++
 +    /* Bottom border */
 +    printf("└");
 +    for (i = 0; i < total_width - 2; i++) {
 +        printf("─");
 +    }
 +    printf("┘\n");
 +}
++
 +/* Print status message with appropriate color and icon */
 +void display_status(const char *level, const char *message, ...) {
 +    va_list args;
 +    char formatted_message[1024];
 +    const char *icon = "";
 +    const char *color_type = "";
++
 +    if (!level || !message) return;
++
 +    /* Format the message */
 +    va_start(args, message);
 +    vsnprintf(formatted_message, sizeof(formatted_message), message, args);
 +    va_end(args);
++
 +    /* Select icon and color based on level */
 +    if (strcmp(level, "success") == 0) {
 +        icon = STATUS_SUCCESS;
 +        color_type = "success";
 +    } else if (strcmp(level, "error") == 0) {
 +        icon = STATUS_ERROR;
 +        color_type = "error";
 +    } else if (strcmp(level, "warning") == 0) {
 +        icon = STATUS_WARNING;
 +        color_type = "warning";
 +    } else if (strcmp(level, "info") == 0) {
 +        icon = STATUS_INFO;
 +        color_type = "info";
 +    } else {
 +        icon = "-";
 +        color_type = "info";
 +    }
++
 +    printf("%s %s\n",
 +           display_colorize(icon, color_type),
 +           display_colorize(formatted_message, color_type));
 +}
++
 +/* Print error message with context */
 +void display_error(const char *context, const char *message, ...) {
 +    va_list args;
 +    char formatted_message[1024];
++
 +    if (!message) return;
++
 +    va_start(args, message);
 +    vsnprintf(formatted_message, sizeof(formatted_message), message, args);
 +    va_end(args);
++
 +    if (context) {
 +        display_status("error", "%s: %s", context, formatted_message);
 +    } else {
 +        display_status("error", "%s", formatted_message);
 +    }
 +}
++
 +/* Print warning message */
 +void display_warning(const char *message, ...) {
 +    va_list args;
 +    char formatted_message[1024];
++
 +    if (!message) return;
++
 +    va_start(args, message);
 +    vsnprintf(formatted_message, sizeof(formatted_message), message, args);
 +    va_end(args);
++
 +    display_status("warning", "%s", formatted_message);
 +}
++
 +/* Print success message */
 +void display_success(const char *message, ...) {
 +    va_list args;
 +    char formatted_message[1024];
++
 +    if (!message) return;
++
 +    va_start(args, message);
 +    vsnprintf(formatted_message, sizeof(formatted_message), message, args);
 +    va_end(args);
++
 +    display_status("success", "%s", formatted_message);
 +}
++
 +/* Print info message */
 +void display_info(const char *message, ...) {
 +    va_list args;
 +    char formatted_message[1024];
++
 +    if (!message) return;
++
 +    va_start(args, message);
 +    vsnprintf(formatted_message, sizeof(formatted_message), message, args);
 +    va_end(args);
++
 +    display_status("info", "%s", formatted_message);
 +}
++
 +/* Format table with proper column alignment */
 +void display_table_header(const char **headers, const int *widths, int columns) {
 +    int i;
++
 +    if (!headers || !widths || columns <= 0) return;
++
 +    /* Print header row */
 +    printf("│");
 +    for (i = 0; i < columns; i++) {
 +        printf(" %s%-*s%s │",
 +               display_colorize("", "header"),
 +               widths[i] - 1, headers[i],
 +               COLOR_RESET);
 +    }
 +    printf("\n");
++
 +    /* Print separator */
 +    printf("├");
 +    for (i = 0; i < columns; i++) {
 +        int j;
 +        for (j = 0; j < widths[i] + 1; j++) {
 +            printf("─");
 +        }
 +        printf(i < columns - 1 ? "┼" : "┤");
 +    }
 +    printf("\n");
 +}
++
 +void display_table_row(const char **values, const int *widths, int columns) {
 +    int i;
++
 +    if (!values || !widths || columns <= 0) return;
++
 +    printf("│");
 +    for (i = 0; i < columns; i++) {
 +        printf(" %-*s │", widths[i] - 1, values[i] ? values[i] : "");
 +    }
 +    printf("\n");
 +}
++
 +void display_table_separator(const int *widths, int columns) {
 +    int i;
++
 +    if (!widths || columns <= 0) return;
++
 +    printf("└");
 +    for (i = 0; i < columns; i++) {
 +        int j;
 +        for (j = 0; j < widths[i] + 1; j++) {
 +            printf("─");
 +        }
 +        printf(i < columns - 1 ? "┴" : "┘");
 +    }
 +    printf("\n");
 +}
++
 +/* Print account information in formatted table */
 +void display_account(const account_t *account, bool is_current) {
 +    if (!account) return;
++
 +    const char *marker = is_current ? "→" : " ";
 +    const char *color_type = is_current ? "current" : "inactive";
++
 +    printf("%s %s%3u%s │ %s%-20s%s │ %s%-30s%s │ %s%s%s\n",
 +           display_colorize(marker, color_type),
 +           display_colorize("", color_type), account->id, COLOR_RESET,
 +           display_colorize("", color_type), account->name, COLOR_RESET,
 +           display_colorize("", color_type), account->email, COLOR_RESET,
 +           display_colorize("", color_type), account->description, COLOR_RESET);
 +}
++
 +/* Print accounts list in formatted table */
 +void display_accounts_list(const gitswitch_ctx_t *ctx) {
 +    const char *headers[] = {"", "ID", "Name", "Email", "Description"};
 +    const int widths[] = {3, 5, 22, 32, 30};
 +    size_t i;
++
 +    if (!ctx) return;
++
 +    if (ctx->account_count == 0) {
 +        display_info("No accounts configured");
 +        display_info("Run 'gitswitch add' to create your first account");
 +        return;
 +    }
++
 +    printf("\n");
 +    display_header("Configured Accounts");
 +    printf("\n");
++
 +    /* Print table */
 +    display_table_header(headers, widths, 5);
++
 +    for (i = 0; i < ctx->account_count; i++) {
 +        bool is_current = ctx->current_account &&
 +                         ctx->current_account->id == ctx->accounts[i].id;
 +        display_account(&ctx->accounts[i], is_current);
 +    }
++
 +    display_table_separator(widths, 5);
 +    printf("\n");
 +}
++
 +/* These functions will be implemented in later phases when we have git/ssh/gpg components
++
 +void display_current_status(const git_current_config_t *config) { ... }
 +void display_ssh_status(const ssh_config_t *ssh_config) { ... }
 +void display_gpg_status(const gpg_config_t *gpg_config) { ... }
 +void display_validation_results(const account_validation_t *validation) { ... }
++
 +*/
++
 +/* Print health check results */
 +void display_health_check(const gitswitch_ctx_t *ctx) {
 +    if (!ctx) return;
++
 +    printf("\n");
 +    display_header("System Health Check");
 +    printf("\n");
++
 +    /* Check git availability */
 +    if (command_exists("git")) {
 +        display_success("Git is available");
 +    } else {
 +        display_error("Git command not found", "Install git to use gitswitch");
 +    }
++
 +    /* Check SSH agent */
 +    if (command_exists("ssh-agent")) {
 +        display_success("SSH agent is available");
 +    } else {
 +        display_warning("SSH agent not found - SSH key management may not work");
 +    }
++
 +    /* Check GPG */
 +    if (command_exists("gpg") || command_exists("gpg2")) {
 +        display_success("GPG is available");
 +    } else {
 +        display_warning("GPG not found - GPG signing will not work");
 +    }
++
 +    /* Check configuration */
 +    char config_path[MAX_PATH_LEN];
 +    if (get_config_directory(config_path, sizeof(config_path)) == 0) {
 +        if (is_directory(config_path)) {
 +            display_success("Configuration directory exists: %s", config_path);
 +        } else {
 +            display_warning("Configuration directory not found: %s", config_path);
 +        }
 +    }
++
 +    printf("\n");
 +}
++
 +/* Display interactive account selection menu */
 +uint32_t display_account_menu(const gitswitch_ctx_t *ctx) {
 +    char input[64];
 +    char *endptr;
 +    unsigned long selected_id;
++
 +    if (!ctx || ctx->account_count == 0) {
 +        display_error("No accounts available", "");
 +        return 0;
 +    }
++
 +    display_accounts_list(ctx);
++
 +    printf("Select account (ID or name): ");
 +    fflush(stdout);
++
 +    if (!fgets(input, sizeof(input), stdin)) {
 +        display_error("Failed to read input", "");
 +        return 0;
 +    }
++
 +    /* Remove trailing newline */
 +    input[strcspn(input, "\n")] = '\0';
 +    trim_whitespace(input);
++
 +    if (string_empty(input)) {
 +        return 0; /* User cancelled */
 +    }
++
 +    /* Try to parse as number first */
 +    selected_id = strtoul(input, &endptr, 10);
 +    if (*endptr == '\0' && selected_id > 0) {
 +        /* It's a valid number - verify it exists */
 +        for (size_t i = 0; i < ctx->account_count; i++) {
 +            if (ctx->accounts[i].id == (uint32_t)selected_id) {
 +                return (uint32_t)selected_id;
 +            }
 +        }
 +        display_error("Account ID not found", "%lu", selected_id);
 +        return 0;
 +    }
++
 +    /* Search by name/description */
 +    account_t *found = find_account_in_array((account_t *)ctx->accounts,
 +                                            ctx->account_count, input);
 +    if (found) {
 +        return found->id;
 +    }
++
 +    display_error("Account not found", "%s", input);
 +    return 0;
 +}
++
 +/* Prompt user for account information during add/edit */
 +int display_prompt_account_info(account_t *account, bool is_edit) {
 +    char input[512];
 +    char *trimmed;
++
 +    if (!account) {
 +        set_error(ERR_INVALID_ARGS, "NULL account to display_prompt_account_info");
 +        return -1;
 +    }
++
 +    printf("\n");
 +    display_header(is_edit ? "Edit Account" : "Add New Account");
 +    printf("\n");
++
 +    /* Name */
 +    printf("Name%s: ", is_edit ? " (current: " : "");
 +    if (is_edit && account->name[0] != '\0') {
 +        printf("%s): ", account->name);
 +    }
 +    fflush(stdout);
++
 +    if (fgets(input, sizeof(input), stdin) && strlen(input) > 1) {
 +        trimmed = trim_whitespace(input);
 +        trimmed[strcspn(trimmed, "\n")] = '\0';
 +        if (strlen(trimmed) > 0 && validate_name(trimmed)) {
 +            safe_strncpy(account->name, trimmed, sizeof(account->name));
 +        } else if (!is_edit) {
 +            display_error("Invalid name", "Name cannot be empty");
 +            return -1;
 +        }
 +    }
++
 +    /* Email */
 +    printf("Email%s: ", is_edit ? " (current: " : "");
 +    if (is_edit && account->email[0] != '\0') {
 +        printf("%s): ", account->email);
 +    }
 +    fflush(stdout);
++
 +    if (fgets(input, sizeof(input), stdin) && strlen(input) > 1) {
 +        trimmed = trim_whitespace(input);
 +        trimmed[strcspn(trimmed, "\n")] = '\0';
 +        if (strlen(trimmed) > 0 && validate_email(trimmed)) {
 +            safe_strncpy(account->email, trimmed, sizeof(account->email));
 +        } else if (!is_edit) {
 +            display_error("Invalid email", "Please enter a valid email address");
 +            return -1;
 +        }
 +    }
++
 +    /* Description */
 +    printf("Description%s: ", is_edit ? " (current: " : "");
 +    if (is_edit && account->description[0] != '\0') {
 +        printf("%s): ", account->description);
 +    }
 +    fflush(stdout);
++
 +    if (fgets(input, sizeof(input), stdin) && strlen(input) > 1) {
 +        trimmed = trim_whitespace(input);
 +        trimmed[strcspn(trimmed, "\n")] = '\0';
 +        if (strlen(trimmed) > 0) {
 +            safe_strncpy(account->description, trimmed, sizeof(account->description));
 +        }
 +    }
++
 +    /* SSH Key Path */
 +    printf("SSH Key Path (optional)%s: ", is_edit ? " (current: " : "");
 +    if (is_edit && account->ssh_key_path[0] != '\0') {
 +        printf("%s): ", account->ssh_key_path);
 +    }
 +    fflush(stdout);
++
 +    if (fgets(input, sizeof(input), stdin) && strlen(input) > 1) {
 +        trimmed = trim_whitespace(input);
 +        trimmed[strcspn(trimmed, "\n")] = '\0';
 +        if (strlen(trimmed) > 0) {
 +            char expanded[MAX_PATH_LEN];
 +            if (expand_path(trimmed, expanded, sizeof(expanded)) == 0 &&
 +                path_exists(expanded)) {
 +                safe_strncpy(account->ssh_key_path, expanded, sizeof(account->ssh_key_path));
 +                account->ssh_enabled = true;
 +            } else {
 +                display_warning("SSH key file not found: %s", trimmed);
 +                account->ssh_enabled = false;
 +            }
 +        }
 +    }
++
 +    /* GPG Key ID */
 +    printf("GPG Key ID (optional)%s: ", is_edit ? " (current: " : "");
 +    if (is_edit && account->gpg_key_id[0] != '\0') {
 +        printf("%s): ", account->gpg_key_id);
 +    }
 +    fflush(stdout);
++
 +    if (fgets(input, sizeof(input), stdin) && strlen(input) > 1) {
 +        trimmed = trim_whitespace(input);
 +        trimmed[strcspn(trimmed, "\n")] = '\0';
 +        if (strlen(trimmed) > 0 && validate_key_id(trimmed)) {
 +            safe_strncpy(account->gpg_key_id, trimmed, sizeof(account->gpg_key_id));
 +            account->gpg_enabled = true;
++
 +            /* Ask about GPG signing */
 +            printf("Enable GPG signing? (y/N): ");
 +            fflush(stdout);
 +            if (fgets(input, sizeof(input), stdin)) {
 +                trimmed = trim_whitespace(input);
 +                account->gpg_signing_enabled = (tolower(trimmed[0]) == 'y');
 +            }
 +        }
 +    }
++
 +    return 0;
 +}
++
 +/* Confirm dangerous operations */
 +bool display_confirm(const char *message, ...) {
 +    va_list args;
 +    char formatted_message[1024];
 +    char input[64];
 +    char *trimmed;
++
 +    if (!message) return false;
++
 +    va_start(args, message);
 +    vsnprintf(formatted_message, sizeof(formatted_message), message, args);
 +    va_end(args);
++
 +    printf("%s %s (y/N): ",
 +           display_colorize(STATUS_WARNING, "warning"),
 +           formatted_message);
 +    fflush(stdout);
++
 +    if (!fgets(input, sizeof(input), stdin)) {
 +        return false;
 +    }
++
 +    trimmed = trim_whitespace(input);
 +    return tolower(trimmed[0]) == 'y';
 +}
++
 +/* Display progress indicator for long operations */
 +void display_progress(const char *operation, int percent) {
 +    const int bar_width = 40;
 +    int filled = (percent * bar_width) / 100;
 +    int i;
++
 +    if (!operation) return;
++
 +    printf("\r%s [", operation);
++
 +    for (i = 0; i < bar_width; i++) {
 +        if (i < filled) {
 +            printf("█");
 +        } else {
 +            printf("░");
 +        }
 +    }
++
 +    printf("] %3d%%", percent);
 +    fflush(stdout);
++
 +    if (percent >= 100) {
 +        printf("\n");
 +    }
 +}
++
 +/* Clear current line */
 +void display_clear_line(void) {
 +    printf("\r\033[K");
 +    fflush(stdout);
 +}
++
 +/* Get user input with prompt and validation */
 +int display_get_input(const char *prompt, char *buffer, size_t buffer_size,
 +                      bool (*validator)(const char *)) {
 +    char *trimmed;
++
 +    if (!prompt || !buffer || buffer_size == 0) {
 +        set_error(ERR_INVALID_ARGS, "Invalid arguments to display_get_input");
 +        return -1;
 +    }
++
 +    printf("%s: ", prompt);
 +    fflush(stdout);
++
 +    if (!fgets(buffer, buffer_size, stdin)) {
 +        set_error(ERR_FILE_IO, "Failed to read user input");
 +        return -1;
 +    }
++
 +    trimmed = trim_whitespace(buffer);
 +    trimmed[strcspn(trimmed, "\n")] = '\0';
++
 +    /* Move trimmed string to start of buffer */
 +    if (trimmed != buffer) {
 +        memmove(buffer, trimmed, strlen(trimmed) + 1);
 +    }
++
 +    /* Validate if validator provided */
 +    if (validator && !validator(buffer)) {
 +        set_error(ERR_INVALID_ARGS, "Input validation failed");
 +        return -1;
 +    }
++
 +    return 0;
 +}
++
 +/* Get password/sensitive input (hidden) */
 +int display_get_password(const char *prompt, char *buffer, size_t buffer_size) {
 +    char *trimmed;
++
 +    if (!prompt || !buffer || buffer_size == 0) {
 +        set_error(ERR_INVALID_ARGS, "Invalid arguments to display_get_password");
 +        return -1;
 +    }
++
 +    printf("%s: ", prompt);
 +    fflush(stdout);
++
 +    /* Disable echo */
 +    disable_echo();
++
 +    if (!fgets(buffer, buffer_size, stdin)) {
 +        enable_echo();
 +        printf("\n");
 +        set_error(ERR_FILE_IO, "Failed to read password input");
 +        return -1;
 +    }
++
 +    /* Re-enable echo */
 +    enable_echo();
 +    printf("\n");
++
 +    trimmed = trim_whitespace(buffer);
 +    trimmed[strcspn(trimmed, "\n")] = '\0';
++
 +    /* Move trimmed string to start of buffer */
 +    if (trimmed != buffer) {
 +        memmove(buffer, trimmed, strlen(trimmed) + 1);
 +    }
++
 +    return 0;
 +}
++
 +/* Show help text */
 +void display_help(const char *command) {
 +    printf("\n");
 +    display_header("gitswitch-c Help");
 +    printf("\n");
++
 +    if (!command) {
 +        /* General help */
 +        printf("Usage: gitswitch [OPTIONS] [COMMAND] [ARGS]\n\n");
 +        printf("Commands:\n");
 +        printf("  list                 List all configured accounts\n");
 +        printf("  switch <account>     Switch to specified account\n");
 +        printf("  add                  Add new account interactively\n");
 +        printf("  remove <account>     Remove specified account\n");
 +        printf("  status               Show current git configuration\n");
 +        printf("  doctor               Run system health checks\n\n");
 +        printf("Options:\n");
 +        printf("  --global             Set git config globally\n");
 +        printf("  --local              Set git config locally (default)\n");
 +        printf("  --no-ssh             Skip SSH key management\n");
 +        printf("  --no-gpg             Skip GPG key management\n");
 +        printf("  --dry-run            Show what would be done without executing\n");
 +        printf("  --verbose            Enable verbose output\n");
 +        printf("  --color              Force color output\n");
 +        printf("  --no-color           Disable color output\n");
 +        printf("  --help               Show this help message\n");
 +        printf("  --version            Show version information\n\n");
 +        printf("Examples:\n");
 +        printf("  gitswitch                    # Interactive account selection\n");
 +        printf("  gitswitch list               # List all accounts\n");
 +        printf("  gitswitch switch 1           # Switch to account ID 1\n");
 +        printf("  gitswitch switch work        # Switch to account matching 'work'\n");
 +        printf("  gitswitch add                # Add new account\n");
 +        printf("  gitswitch doctor             # Check system health\n");
 +    }
++
 +    printf("\n");
 +}
++
 +/* Display version and build information */
 +void display_version(void) {
 +    printf("%s version %s\n", GITSWITCH_NAME, GITSWITCH_VERSION);
 +    printf("Safe git identity switching with SSH/GPG isolation\n");
 +    printf("Built with security and reliability in mind\n\n");
 +    printf("Features:\n");
 +    printf("- Isolated SSH agents per account\n");
 +    printf("- Separate GPG environments\n");
 +    printf("- Comprehensive validation\n");
 +    printf("- Secure memory handling\n");
 +}
++
 +/* Print configuration file location and status */
 +void display_config_info(const gitswitch_ctx_t *ctx) {
 +    if (!ctx) return;
++
 +    printf("\n");
 +    printf("Configuration: %s\n", ctx->config.config_path);
 +    printf("Accounts:      %zu configured\n", ctx->account_count);
++
 +    if (path_exists(ctx->config.config_path)) {
 +        printf("Status:        %s\n", display_colorize("exists", "success"));
 +    } else {
 +        printf("Status:        %s\n", display_colorize("not found", "warning"));
 +    }
 +}

src/error.cadded

 +/* Error handling and logging utilities
 + * Provides comprehensive error tracking and safe logging for gitswitch-c
 + */
++
 +#include <stdio.h>
 +#include <stdlib.h>
 +#include <string.h>
 +#include <stdarg.h>
 +#include <time.h>
 +#include <unistd.h>
 +#include <errno.h>
 +#include <sys/stat.h>
 +#include <sys/mman.h>
++
 +#include "error.h"
 +#include "gitswitch.h"
++
 +/* Global error context */
 +error_context_t g_last_error = {0};
++
 +/* Logging configuration */
 +log_level_t g_log_level = LOG_LEVEL_INFO;
 +FILE *g_log_file = NULL;
 +bool g_log_to_stderr = true;
++
 +/* Error code to string mapping */
 +static const struct {
 +    error_code_t code;
 +    const char *message;
 +} error_messages[] = {
 +    {ERR_SUCCESS, "Success"},
 +    {ERR_INVALID_ARGS, "Invalid arguments"},
 +    {ERR_CONFIG_NOT_FOUND, "Configuration file not found"},
 +    {ERR_CONFIG_INVALID, "Configuration file is invalid"},
 +    {ERR_CONFIG_WRITE_FAILED, "Failed to write configuration"},
 +    {ERR_ACCOUNT_NOT_FOUND, "Account not found"},
 +    {ERR_ACCOUNT_INVALID, "Account configuration is invalid"},
 +    {ERR_ACCOUNT_EXISTS, "Account already exists"},
 +    {ERR_GIT_NOT_FOUND, "Git command not found"},
 +    {ERR_GIT_CONFIG_FAILED, "Git configuration operation failed"},
 +    {ERR_GIT_NOT_REPO, "Not a git repository"},
 +    {ERR_GIT_CONFIG_NOT_FOUND, "Git configuration not found"},
 +    {ERR_GIT_REPOSITORY_INVALID, "Git repository is invalid"},
 +    {ERR_SSH_AGENT_FAILED, "SSH agent operation failed"},
 +    {ERR_SSH_KEY_FAILED, "SSH key operation failed"},
 +    {ERR_SSH_KEY_NOT_FOUND, "SSH key not found"},
 +    {ERR_SSH_CONNECTION_FAILED, "SSH connection test failed"},
 +    {ERR_SSH_NOT_FOUND, "SSH command not found"},
 +    {ERR_SSH_AGENT_NOT_FOUND, "SSH agent command not found"},
 +    {ERR_SSH_KEY_LOAD_FAILED, "Failed to load SSH key"},
 +    {ERR_SSH_AGENT_START_FAILED, "Failed to start SSH agent"},
 +    {ERR_SSH_KEY_INVALID, "SSH key file is invalid"},
 +    {ERR_SSH_KEY_PERMISSIONS, "SSH key file has wrong permissions"},
 +    {ERR_SSH_KEY_OWNERSHIP, "SSH key file has wrong ownership"},
 +    {ERR_SSH_AGENT_SOCKET_INVALID, "SSH agent socket is invalid"},
 +    {ERR_GPG_NOT_FOUND, "GPG command not found"},
 +    {ERR_GPG_KEY_FAILED, "GPG key operation failed"},
 +    {ERR_GPG_KEY_NOT_FOUND, "GPG key not found"},
 +    {ERR_GPG_SIGNING_FAILED, "GPG signing operation failed"},
 +    {ERR_MEMORY_ALLOCATION, "Memory allocation failed"},
 +    {ERR_FILE_IO, "File I/O operation failed"},
 +    {ERR_PERMISSION_DENIED, "Permission denied"},
 +    {ERR_NETWORK_ERROR, "Network operation failed"},
 +    {ERR_SYSTEM_CALL, "System call failed"},
 +    {ERR_SYSTEM_REQUIREMENT, "System requirement not met"},
 +    {ERR_SYSTEM_COMMAND_FAILED, "System command execution failed"},
 +    {ERR_INVALID_PATH, "Invalid file path"},
 +    {ERR_UNKNOWN, "Unknown error"}
 +};
++
 +/* Log level to string mapping */
 +static const char* log_level_strings[] = {
 +    "DEBUG", "INFO", "WARN", "ERROR", "CRIT"
 +};
++
 +/* Initialize error handling and logging system */
 +int error_init(log_level_t level, const char *log_file_path) {
 +    g_log_level = level;
++
 +    /* Close existing log file if open */
 +    if (g_log_file && g_log_file != stderr) {
 +        fclose(g_log_file);
 +        g_log_file = NULL;
 +    }
++
 +    /* Open new log file if specified */
 +    if (log_file_path) {
 +        g_log_file = fopen(log_file_path, "a");
 +        if (!g_log_file) {
 +            /* Fall back to stderr if file can't be opened */
 +            g_log_file = stderr;
 +            set_error(ERR_FILE_IO, "Failed to open log file: %s", log_file_path);
 +            return -1;
 +        }
 +        /* Set log file to line buffered for immediate output */
 +        setvbuf(g_log_file, NULL, _IOLBF, 0);
 +    } else {
 +        g_log_file = stderr;
 +    }
++
 +    /* Clear any existing error */
 +    clear_error();
++
 +    log_info("Error handling system initialized (level=%s)",
 +             log_level_strings[level]);
++
 +    return 0;
 +}
++
 +/* Cleanup error handling system */
 +void error_cleanup(void) {
 +    if (g_log_file && g_log_file != stderr) {
 +        log_info("Error handling system shutting down");
 +        fclose(g_log_file);
 +        g_log_file = NULL;
 +    }
++
 +    /* Clear error context */
 +    clear_error();
 +}
++
 +/* Set error context with detailed information */
 +void set_error_context(error_code_t code, const char *file, int line,
 +                       const char *function, const char *fmt, ...) {
 +    va_list args;
++
 +    /* Clear previous error */
 +    memset(&g_last_error, 0, sizeof(g_last_error));
++
 +    g_last_error.code = code;
 +    g_last_error.file = file;
 +    g_last_error.line = line;
 +    g_last_error.function = function;
 +    g_last_error.system_errno = 0;
++
 +    /* Format the error message */
 +    if (fmt) {
 +        va_start(args, fmt);
 +        vsnprintf(g_last_error.message, sizeof(g_last_error.message), fmt, args);
 +        va_end(args);
 +    } else {
 +        strncpy(g_last_error.message, error_code_to_string(code),
 +                sizeof(g_last_error.message) - 1);
 +    }
++
 +    /* Log the error */
 +    log_error("Error set: %s (%s:%d in %s)",
 +              g_last_error.message, file, line, function);
 +}
++
 +/* Set error context including system errno */
 +void set_system_error_context(error_code_t code, const char *file, int line,
 +                              const char *function, const char *fmt, ...) {
 +    va_list args;
 +    int saved_errno = errno; /* Save errno before any other operations */
++
 +    /* Clear previous error */
 +    memset(&g_last_error, 0, sizeof(g_last_error));
++
 +    g_last_error.code = code;
 +    g_last_error.file = file;
 +    g_last_error.line = line;
 +    g_last_error.function = function;
 +    g_last_error.system_errno = saved_errno;
++
 +    /* Format the error message */
 +    if (fmt) {
 +        va_start(args, fmt);
 +        vsnprintf(g_last_error.message, sizeof(g_last_error.message), fmt, args);
 +        va_end(args);
 +    } else {
 +        strncpy(g_last_error.message, error_code_to_string(code),
 +                sizeof(g_last_error.message) - 1);
 +    }
++
 +    /* Add system error details */
 +    if (saved_errno != 0) {
 +        int msg_len = strlen(g_last_error.message);
 +        snprintf(g_last_error.details, sizeof(g_last_error.details),
 +                 "System error: %s (errno=%d)", strerror(saved_errno), saved_errno);
++
 +        /* Append system error to message if there's room */
 +        if (msg_len < sizeof(g_last_error.message) - 50) {
 +            snprintf(g_last_error.message + msg_len,
 +                    sizeof(g_last_error.message) - msg_len,
 +                    " (%s)", strerror(saved_errno));
 +        }
 +    }
++
 +    /* Log the error with system details */
 +    log_error("System error: %s [errno=%d: %s] (%s:%d in %s)",
 +              g_last_error.message, saved_errno, strerror(saved_errno),
 +              file, line, function);
 +}
++
 +/* Get last error information */
 +const error_context_t *get_last_error(void) {
 +    return &g_last_error;
 +}
++
 +/* Clear last error */
 +void clear_error(void) {
 +    memset(&g_last_error, 0, sizeof(g_last_error));
 +}
++
 +/* Convert error code to human-readable string */
 +const char *error_code_to_string(error_code_t code) {
 +    for (size_t i = 0; i < sizeof(error_messages) / sizeof(error_messages[0]); i++) {
 +        if (error_messages[i].code == code) {
 +            return error_messages[i].message;
 +        }
 +    }
 +    return "Unknown error code";
 +}
++
 +/* Log message with context information */
 +void log_message(log_level_t level, const char *file, int line,
 +                 const char *function, const char *fmt, ...) {
 +    va_list args;
 +    char timestamp[32];
 +    char message[1024];
++
 +    /* Check if this level should be logged */
 +    if (!should_log(level)) {
 +        return;
 +    }
++
 +    /* Format the message */
 +    va_start(args, fmt);
 +    vsnprintf(message, sizeof(message), fmt, args);
 +    va_end(args);
++
 +    /* Get timestamp */
 +    get_timestamp(timestamp, sizeof(timestamp));
++
 +    /* Format complete log entry */
 +    const char *level_str = (level < LOG_LEVEL_CRITICAL) ?
 +        log_level_strings[level] : "UNKNOWN";
++
 +    /* Log to file/stderr */
 +    if (g_log_file) {
 +        fprintf(g_log_file, "[%s] %s %s:%d (%s) - %s\n",
 +                timestamp, level_str, file, line, function, message);
 +        fflush(g_log_file);
 +    }
++
 +    /* Also log to stderr if enabled and not already logging there */
 +    if (g_log_to_stderr && g_log_file != stderr) {
 +        fprintf(stderr, "[%s] %s - %s\n", timestamp, level_str, message);
 +    }
 +}
++
 +/* Set logging level */
 +void set_log_level(log_level_t level) {
 +    g_log_level = level;
 +    log_info("Log level changed to %s", log_level_strings[level]);
 +}
++
 +/* Set log output file */
 +int set_log_file(const char *file_path) {
 +    FILE *new_file = NULL;
++
 +    if (file_path) {
 +        new_file = fopen(file_path, "a");
 +        if (!new_file) {
 +            set_system_error(ERR_FILE_IO, "Failed to open log file: %s", file_path);
 +            return -1;
 +        }
 +        setvbuf(new_file, NULL, _IOLBF, 0);
 +    } else {
 +        new_file = stderr;
 +    }
++
 +    /* Close old file if it's not stderr */
 +    if (g_log_file && g_log_file != stderr) {
 +        fclose(g_log_file);
 +    }
++
 +    g_log_file = new_file;
 +    log_info("Log output changed to %s", file_path ? file_path : "stderr");
++
 +    return 0;
 +}
++
 +/* Enable/disable logging to stderr */
 +void set_log_to_stderr(bool enable) {
 +    g_log_to_stderr = enable;
 +}
++
 +/* Format error message for user display */
 +void format_error_message(char *buffer, size_t buffer_size,
 +                          const error_context_t *error) {
 +    if (!buffer || buffer_size == 0 || !error) {
 +        return;
 +    }
++
 +    if (error->system_errno != 0) {
 +        snprintf(buffer, buffer_size,
 +                "Error: %s\nDetails: %s\nLocation: %s:%d in %s()",
 +                error->message, error->details,
 +                error->file, error->line, error->function);
 +    } else {
 +        snprintf(buffer, buffer_size,
 +                "Error: %s\nLocation: %s:%d in %s()",
 +                error->message, error->file, error->line, error->function);
 +    }
 +}
++
 +/* Print formatted error to stderr */
 +void print_error(const char *prefix) {
 +    char error_msg[2048];
++
 +    if (g_last_error.code == ERR_SUCCESS) {
 +        return; /* No error to print */
 +    }
++
 +    format_error_message(error_msg, sizeof(error_msg), &g_last_error);
++
 +    if (prefix) {
 +        fprintf(stderr, "%s: %s\n", prefix, error_msg);
 +    } else {
 +        fprintf(stderr, "%s\n", error_msg);
 +    }
 +}
++
 +/* Check if error level should be logged */
 +bool should_log(log_level_t level) {
 +    return level >= g_log_level;
 +}
++
 +/* Get current timestamp for logging */
 +void get_timestamp(char *buffer, size_t buffer_size) {
 +    time_t now;
 +    struct tm *tm_info;
++
 +    if (!buffer || buffer_size == 0) {
 +        return;
 +    }
++
 +    time(&now);
 +    tm_info = localtime(&now);
++
 +    if (tm_info) {
 +        strftime(buffer, buffer_size, "%Y-%m-%d %H:%M:%S", tm_info);
 +    } else {
 +        strncpy(buffer, "UNKNOWN-TIME", buffer_size - 1);
 +        buffer[buffer_size - 1] = '\0';
 +    }
 +}
++
 +/* Safe string copy with error context */
 +int safe_strncpy(char *dest, const char *src, size_t dest_size) {
 +    if (!dest || !src || dest_size == 0) {
 +        set_error(ERR_INVALID_ARGS, "Invalid arguments to safe_strncpy");
 +        return -1;
 +    }
++
 +    size_t src_len = strlen(src);
 +    if (src_len >= dest_size) {
 +        set_error(ERR_INVALID_ARGS, "String too long for destination buffer");
 +        return -1;
 +    }
++
 +    strncpy(dest, src, dest_size - 1);
 +    dest[dest_size - 1] = '\0';
 +    return 0;
 +}
++
 +/* Safe string concatenation with error context */
 +int safe_strncat(char *dest, const char *src, size_t dest_size) {
 +    if (!dest || !src || dest_size == 0) {
 +        set_error(ERR_INVALID_ARGS, "Invalid arguments to safe_strncat");
 +        return -1;
 +    }
++
 +    size_t dest_len = strlen(dest);
 +    size_t src_len = strlen(src);
++
 +    if (dest_len + src_len >= dest_size) {
 +        set_error(ERR_INVALID_ARGS, "String concatenation would overflow buffer");
 +        return -1;
 +    }
++
 +    strncat(dest, src, dest_size - dest_len - 1);
 +    return 0;
 +}
++
 +/* Safe snprintf with error context */
 +int safe_snprintf(char *buffer, size_t buffer_size, const char *fmt, ...) {
 +    va_list args;
 +    int result;
++
 +    if (!buffer || !fmt || buffer_size == 0) {
 +        set_error(ERR_INVALID_ARGS, "Invalid arguments to safe_snprintf");
 +        return -1;
 +    }
++
 +    va_start(args, fmt);
 +    result = vsnprintf(buffer, buffer_size, fmt, args);
 +    va_end(args);
++
 +    if (result < 0) {
 +        set_error(ERR_INVALID_ARGS, "snprintf formatting error");
 +        return -1;
 +    }
++
 +    if ((size_t)result >= buffer_size) {
 +        set_error(ERR_INVALID_ARGS, "snprintf output truncated");
 +        return -1;
 +    }
++
 +    return result;
 +}
++
 +/* Safe memory allocation with error context */
 +void *safe_malloc(size_t size) {
 +    void *ptr;
++
 +    if (size == 0) {
 +        set_error(ERR_INVALID_ARGS, "Attempted to allocate zero bytes");
 +        return NULL;
 +    }
++
 +    ptr = malloc(size);
 +    if (!ptr) {
 +        set_system_error(ERR_MEMORY_ALLOCATION, "Failed to allocate %zu bytes", size);
 +        return NULL;
 +    }
++
 +    return ptr;
 +}
++
 +/* Safe calloc with error context */
 +void *safe_calloc(size_t nmemb, size_t size) {
 +    void *ptr;
++
 +    if (nmemb == 0 || size == 0) {
 +        set_error(ERR_INVALID_ARGS, "Attempted to allocate zero elements");
 +        return NULL;
 +    }
++
 +    ptr = calloc(nmemb, size);
 +    if (!ptr) {
 +        set_system_error(ERR_MEMORY_ALLOCATION,
 +                        "Failed to allocate %zu elements of %zu bytes", nmemb, size);
 +        return NULL;
 +    }
++
 +    return ptr;
 +}
++
 +/* Safe realloc with error context */
 +void *safe_realloc(void *ptr, size_t size) {
 +    void *new_ptr;
++
 +    if (size == 0) {
 +        set_error(ERR_INVALID_ARGS, "Attempted to reallocate to zero bytes");
 +        return NULL;
 +    }
++
 +    new_ptr = realloc(ptr, size);
 +    if (!new_ptr) {
 +        set_system_error(ERR_MEMORY_ALLOCATION, "Failed to reallocate to %zu bytes", size);
 +        return NULL;
 +    }
++
 +    return new_ptr;
 +}

src/git_ops.cadded

 +/* Git configuration operations with comprehensive validation and security
 + * Implements safe git configuration management for gitswitch-c
 + */
++
 +#define _POSIX_C_SOURCE 200809L
 +#include <stdio.h>
 +#include <stdlib.h>
 +#include <string.h>
 +#include <unistd.h>
 +#include <sys/wait.h>
 +#include <sys/stat.h>
++
 +#include "git_ops.h"
 +#include "error.h"
 +#include "utils.h"
 +#include "display.h"
++
 +/* Internal helper functions */
 +static int execute_git_command(const char *args, char *output, size_t output_size);
 +static int validate_git_installation(void);
 +static int detect_repository_scope(git_scope_t *detected_scope);
 +static bool is_valid_git_config_value(const char *value);
 +static int backup_git_config_if_needed(git_scope_t scope);
 +static int restore_git_config_if_needed(git_scope_t scope);
++
 +/* Initialize git operations */
 +int git_ops_init(void) {
 +    log_debug("Initializing git operations");
++
 +    /* Validate git installation */
 +    if (validate_git_installation() != 0) {
 +        set_error(ERR_SYSTEM_REQUIREMENT, "Git validation failed");
 +        return -1;
 +    }
++
 +    log_info("Git operations initialized successfully");
 +    return 0;
 +}
++
 +/* Set git configuration for account */
 +int git_set_config(const account_t *account, git_scope_t scope) {
 +    const char *scope_flag;
++
 +    if (!account) {
 +        set_error(ERR_INVALID_ARGS, "NULL account to git_set_config");
 +        return -1;
 +    }
++
 +    /* Validate account data */
 +    if (!validate_name(account->name)) {
 +        set_error(ERR_ACCOUNT_INVALID, "Invalid account name for git config");
 +        return -1;
 +    }
++
 +    if (!validate_email(account->email)) {
 +        set_error(ERR_ACCOUNT_INVALID, "Invalid account email for git config");
 +        return -1;
 +    }
++
 +    /* Get scope flag */
 +    scope_flag = git_scope_to_flag(scope);
 +    if (!scope_flag) {
 +        set_error(ERR_INVALID_ARGS, "Invalid git scope");
 +        return -1;
 +    }
++
 +    /* If local scope, ensure we're in a git repository */
 +    if (scope == GIT_SCOPE_LOCAL && !git_is_repository()) {
 +        set_error(ERR_GIT_NOT_REPOSITORY, "Not in a git repository, cannot set local config");
 +        return -1;
 +    }
++
 +    /* Backup current configuration if requested */
 +    if (backup_git_config_if_needed(scope) != 0) {
 +        log_warning("Failed to backup git configuration");
 +    }
++
 +    log_info("Setting git configuration for account: %s (%s scope)", account->name, scope_flag);
++
 +    /* Set user.name */
 +    if (git_set_config_value(GIT_CONFIG_USER_NAME, account->name, scope) != 0) {
 +        set_error(ERR_GIT_CONFIG_FAILED, "Failed to set user.name");
 +        return -1;
 +    }
++
 +    /* Set user.email */
 +    if (git_set_config_value(GIT_CONFIG_USER_EMAIL, account->email, scope) != 0) {
 +        set_error(ERR_GIT_CONFIG_FAILED, "Failed to set user.email");
 +        return -1;
 +    }
++
 +    /* Configure GPG if enabled */
 +    if (account->gpg_enabled) {
 +        if (git_configure_gpg(account, scope) != 0) {
 +            log_warning("Failed to configure GPG for git");
 +            /* Don't fail completely, GPG is optional */
 +        }
 +    } else {
 +        /* Disable GPG signing */
 +        git_unset_config_value(GIT_CONFIG_USER_SIGNINGKEY, scope);
 +        git_set_config_value(GIT_CONFIG_COMMIT_GPGSIGN, "false", scope);
 +    }
++
 +    /* Configure SSH if enabled */
 +    if (account->ssh_enabled && strlen(account->ssh_key_path) > 0) {
 +        if (git_configure_ssh(account, scope) != 0) {
 +            log_warning("Failed to configure SSH for git");
 +            /* Don't fail completely, SSH config is optional */
 +        }
 +    } else {
 +        /* Clear SSH configuration */
 +        git_unset_config_value(GIT_CONFIG_CORE_SSHCOMMAND, scope);
 +    }
++
 +    /* Verify configuration was set correctly */
 +    git_current_config_t current_config;
 +    if (git_get_current_config(&current_config) == 0) {
 +        if (strcmp(current_config.name, account->name) != 0 ||
 +            strcmp(current_config.email, account->email) != 0) {
 +            set_error(ERR_GIT_CONFIG_FAILED, "Git configuration verification failed");
 +            return -1;
 +        }
 +    }
++
 +    log_info("Git configuration set successfully for %s", account->name);
 +    return 0;
 +}
++
 +/* Get current git configuration */
 +int git_get_current_config(git_current_config_t *config) {
 +    char name[MAX_NAME_LEN];
 +    char email[MAX_EMAIL_LEN];
 +    char signing_key[MAX_KEY_ID_LEN];
 +    char gpg_sign[16];
++
 +    if (!config) {
 +        set_error(ERR_INVALID_ARGS, "NULL config to git_get_current_config");
 +        return -1;
 +    }
++
 +    /* Initialize structure */
 +    memset(config, 0, sizeof(git_current_config_t));
 +    config->valid = false;
++
 +    /* Try to get user.name */
 +    if (git_get_config_value(GIT_CONFIG_USER_NAME, name, sizeof(name), GIT_SCOPE_LOCAL) == 0) {
 +        config->scope = GIT_SCOPE_LOCAL;
 +    } else if (git_get_config_value(GIT_CONFIG_USER_NAME, name, sizeof(name), GIT_SCOPE_GLOBAL) == 0) {
 +        config->scope = GIT_SCOPE_GLOBAL;
 +    } else if (git_get_config_value(GIT_CONFIG_USER_NAME, name, sizeof(name), GIT_SCOPE_SYSTEM) == 0) {
 +        config->scope = GIT_SCOPE_SYSTEM;
 +    } else {
 +        set_error(ERR_GIT_CONFIG_NOT_FOUND, "No git user.name configured");
 +        return -1;
 +    }
++
 +    /* Get user.email from same scope */
 +    if (git_get_config_value(GIT_CONFIG_USER_EMAIL, email, sizeof(email), config->scope) != 0) {
 +        set_error(ERR_GIT_CONFIG_NOT_FOUND, "No git user.email configured");
 +        return -1;
 +    }
++
 +    /* Copy basic configuration */
 +    safe_strncpy(config->name, name, sizeof(config->name));
 +    safe_strncpy(config->email, email, sizeof(config->email));
++
 +    /* Get GPG configuration if available */
 +    if (git_get_config_value(GIT_CONFIG_USER_SIGNINGKEY, signing_key, sizeof(signing_key), config->scope) == 0) {
 +        safe_strncpy(config->signing_key, signing_key, sizeof(config->signing_key));
 +    }
++
 +    /* Check if GPG signing is enabled */
 +    if (git_get_config_value(GIT_CONFIG_COMMIT_GPGSIGN, gpg_sign, sizeof(gpg_sign), config->scope) == 0) {
 +        config->gpg_signing_enabled = (strcmp(gpg_sign, "true") == 0);
 +    }
++
 +    config->valid = true;
 +    return 0;
 +}
++
 +/* Clear git configuration */
 +int git_clear_config(git_scope_t scope) {
 +    const char *scope_flag;
++
 +    scope_flag = git_scope_to_flag(scope);
 +    if (!scope_flag) {
 +        set_error(ERR_INVALID_ARGS, "Invalid git scope");
 +        return -1;
 +    }
++
 +    log_info("Clearing git configuration (%s scope)", scope_flag);
++
 +    /* Clear basic user configuration */
 +    git_unset_config_value(GIT_CONFIG_USER_NAME, scope);
 +    git_unset_config_value(GIT_CONFIG_USER_EMAIL, scope);
++
 +    /* Clear GPG configuration */
 +    git_unset_config_value(GIT_CONFIG_USER_SIGNINGKEY, scope);
 +    git_unset_config_value(GIT_CONFIG_COMMIT_GPGSIGN, scope);
 +    git_unset_config_value(GIT_CONFIG_GPG_PROGRAM, scope);
++
 +    /* Clear SSH configuration */
 +    git_unset_config_value(GIT_CONFIG_CORE_SSHCOMMAND, scope);
++
 +    log_info("Git configuration cleared");
 +    return 0;
 +}
++
 +/* Validate git repository */
 +int git_validate_repository(void) {
 +    char output[256];
++
 +    if (!git_is_repository()) {
 +        set_error(ERR_GIT_NOT_REPOSITORY, "Current directory is not a git repository");
 +        return -1;
 +    }
++
 +    /* Check if repository is bare */
 +    if (execute_git_command("rev-parse --is-bare-repository", output, sizeof(output)) == 0) {
 +        trim_whitespace(output);
 +        if (strcmp(output, "true") == 0) {
 +            set_error(ERR_GIT_REPOSITORY_INVALID, "Repository is bare");
 +            return -1;
 +        }
 +    }
++
 +    /* Check repository health - verify we can read HEAD */
 +    if (execute_git_command("rev-parse --verify HEAD", output, sizeof(output)) != 0) {
 +        /* This is OK for new repositories with no commits */
 +        log_debug("Repository has no commits yet (new repository)");
 +    }
++
 +    return 0;
 +}
++
 +/* Get git configuration scope */
 +git_scope_t git_get_config_scope(const char *config_key) {
 +    char value[512];
++
 +    if (!config_key) {
 +        return GIT_SCOPE_GLOBAL; /* Default fallback */
 +    }
++
 +    /* Try local scope first if we're in a repository */
 +    if (git_is_repository()) {
 +        if (git_get_config_value(config_key, value, sizeof(value), GIT_SCOPE_LOCAL) == 0) {
 +            return GIT_SCOPE_LOCAL;
 +        }
 +    }
++
 +    /* Try global scope */
 +    if (git_get_config_value(config_key, value, sizeof(value), GIT_SCOPE_GLOBAL) == 0) {
 +        return GIT_SCOPE_GLOBAL;
 +    }
++
 +    /* Try system scope */
 +    if (git_get_config_value(config_key, value, sizeof(value), GIT_SCOPE_SYSTEM) == 0) {
 +        return GIT_SCOPE_SYSTEM;
 +    }
++
 +    /* Default to global if not found */
 +    return GIT_SCOPE_GLOBAL;
 +}
++
 +/* Test git configuration */
 +int git_test_config(const account_t *account, git_scope_t scope) {
 +    git_current_config_t current_config;
 +    (void)scope; /* Suppress unused parameter warning */
++
 +    if (!account) {
 +        set_error(ERR_INVALID_ARGS, "NULL account to git_test_config");
 +        return -1;
 +    }
++
 +    log_info("Testing git configuration for account: %s", account->name);
++
 +    /* Get current configuration and verify it matches */
 +    if (git_get_current_config(&current_config) != 0) {
 +        set_error(ERR_GIT_CONFIG_FAILED, "Failed to read current git configuration");
 +        return -1;
 +    }
++
 +    if (strcmp(current_config.name, account->name) != 0) {
 +        set_error(ERR_GIT_CONFIG_FAILED, "Git user.name does not match account: expected '%s', got '%s'",
 +                  account->name, current_config.name);
 +        return -1;
 +    }
++
 +    if (strcmp(current_config.email, account->email) != 0) {
 +        set_error(ERR_GIT_CONFIG_FAILED, "Git user.email does not match account: expected '%s', got '%s'",
 +                  account->email, current_config.email);
 +        return -1;
 +    }
++
 +    /* Test GPG configuration if enabled */
 +    if (account->gpg_enabled && strlen(account->gpg_key_id) > 0) {
 +        if (strlen(current_config.signing_key) == 0) {
 +            set_error(ERR_GIT_CONFIG_FAILED, "GPG signing key not configured in git");
 +            return -1;
 +        }
++
 +        if (!current_config.gpg_signing_enabled) {
 +            log_warning("GPG signing is configured but not enabled");
 +        }
++
 +        /* Test GPG key availability */
 +        char gpg_test[256];
 +        snprintf(gpg_test, sizeof(gpg_test), "gpg --list-secret-keys '%s' >/dev/null 2>&1",
 +                 account->gpg_key_id);
 +        if (system(gpg_test) != 0) {
 +            set_error(ERR_GPG_KEY_NOT_FOUND, "GPG key not available: %s", account->gpg_key_id);
 +            return -1;
 +        }
 +    }
++
 +    log_info("Git configuration test passed for %s", account->name);
 +    return 0;
 +}
++
 +/* Set single git configuration value */
 +int git_set_config_value(const char *key, const char *value, git_scope_t scope) {
 +    char command[1024];
 +    char output[256];
 +    const char *scope_flag;
++
 +    if (!key || !value) {
 +        set_error(ERR_INVALID_ARGS, "NULL key or value to git_set_config_value");
 +        return -1;
 +    }
++
 +    if (!is_valid_git_config_value(value)) {
 +        set_error(ERR_INVALID_ARGS, "Invalid characters in git config value");
 +        return -1;
 +    }
++
 +    scope_flag = git_scope_to_flag(scope);
 +    if (!scope_flag) {
 +        set_error(ERR_INVALID_ARGS, "Invalid git scope");
 +        return -1;
 +    }
++
 +    /* Build git config command */
 +    if (snprintf(command, sizeof(command), "config %s '%s' '%s'",
 +                 scope_flag, key, value) >= sizeof(command)) {
 +        set_error(ERR_INVALID_ARGS, "Git config command too long");
 +        return -1;
 +    }
++
 +    log_debug("Setting git config: %s = %s (%s)", key, value, scope_flag);
++
 +    if (execute_git_command(command, output, sizeof(output)) != 0) {
 +        set_error(ERR_GIT_CONFIG_FAILED, "Failed to set git config %s: %s", key, output);
 +        return -1;
 +    }
++
 +    return 0;
 +}
++
 +/* Get single git configuration value */
 +int git_get_config_value(const char *key, char *value, size_t value_size, git_scope_t scope) {
 +    char command[512];
 +    char output[512];
 +    const char *scope_flag;
++
 +    if (!key || !value || value_size == 0) {
 +        set_error(ERR_INVALID_ARGS, "Invalid arguments to git_get_config_value");
 +        return -1;
 +    }
++
 +    scope_flag = git_scope_to_flag(scope);
 +    if (!scope_flag) {
 +        set_error(ERR_INVALID_ARGS, "Invalid git scope");
 +        return -1;
 +    }
++
 +    /* Build git config command */
 +    if (snprintf(command, sizeof(command), "config %s '%s'", scope_flag, key) >= sizeof(command)) {
 +        set_error(ERR_INVALID_ARGS, "Git config command too long");
 +        return -1;
 +    }
++
 +    if (execute_git_command(command, output, sizeof(output)) != 0) {
 +        /* Config value not found - this is not always an error */
 +        value[0] = '\0';
 +        return -1;
 +    }
++
 +    /* Remove trailing newline */
 +    trim_whitespace(output);
 +    safe_strncpy(value, output, value_size);
++
 +    return 0;
 +}
++
 +/* Unset git configuration value */
 +int git_unset_config_value(const char *key, git_scope_t scope) {
 +    char command[512];
 +    char output[256];
 +    const char *scope_flag;
++
 +    if (!key) {
 +        set_error(ERR_INVALID_ARGS, "NULL key to git_unset_config_value");
 +        return -1;
 +    }
++
 +    scope_flag = git_scope_to_flag(scope);
 +    if (!scope_flag) {
 +        set_error(ERR_INVALID_ARGS, "Invalid git scope");
 +        return -1;
 +    }
++
 +    /* Build git config unset command */
 +    if (snprintf(command, sizeof(command), "config %s --unset '%s'",
 +                 scope_flag, key) >= sizeof(command)) {
 +        set_error(ERR_INVALID_ARGS, "Git config command too long");
 +        return -1;
 +    }
++
 +    log_debug("Unsetting git config: %s (%s)", key, scope_flag);
++
 +    /* Execute command - ignore errors as key might not exist */
 +    execute_git_command(command, output, sizeof(output));
++
 +    return 0;
 +}
++
 +/* List all git configuration values */
 +int git_list_config(git_scope_t scope, char *output, size_t output_size) {
 +    char command[256];
 +    const char *scope_flag;
++
 +    if (!output || output_size == 0) {
 +        set_error(ERR_INVALID_ARGS, "Invalid arguments to git_list_config");
 +        return -1;
 +    }
++
 +    scope_flag = git_scope_to_flag(scope);
 +    if (!scope_flag) {
 +        set_error(ERR_INVALID_ARGS, "Invalid git scope");
 +        return -1;
 +    }
++
 +    /* Build git config list command */
 +    if (snprintf(command, sizeof(command), "config %s --list", scope_flag) >= sizeof(command)) {
 +        set_error(ERR_INVALID_ARGS, "Git config command too long");
 +        return -1;
 +    }
++
 +    if (execute_git_command(command, output, output_size) != 0) {
 +        set_error(ERR_GIT_CONFIG_FAILED, "Failed to list git configuration");
 +        return -1;
 +    }
++
 +    return 0;
 +}
++
 +/* Configure SSH command for git operations */
 +int git_configure_ssh(const account_t *account, git_scope_t scope) {
 +    char ssh_command[MAX_PATH_LEN * 2];
 +    char expanded_key_path[MAX_PATH_LEN];
++
 +    if (!account || !account->ssh_enabled || strlen(account->ssh_key_path) == 0) {
 +        return 0; /* Nothing to configure */
 +    }
++
 +    /* Expand SSH key path */
 +    if (expand_path(account->ssh_key_path, expanded_key_path, sizeof(expanded_key_path)) != 0) {
 +        set_error(ERR_INVALID_PATH, "Failed to expand SSH key path: %s", account->ssh_key_path);
 +        return -1;
 +    }
++
 +    /* Verify SSH key file exists and has correct permissions */
 +    if (!path_exists(expanded_key_path)) {
 +        set_error(ERR_SSH_KEY_NOT_FOUND, "SSH key file not found: %s", expanded_key_path);
 +        return -1;
 +    }
++
 +    /* Build SSH command with security options */
 +    if (snprintf(ssh_command, sizeof(ssh_command),
 +                 "ssh -i '%s' -o IdentitiesOnly=yes -o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no",
 +                 expanded_key_path) >= sizeof(ssh_command)) {
 +        set_error(ERR_INVALID_ARGS, "SSH command too long");
 +        return -1;
 +    }
++
 +    log_debug("Configuring SSH command: %s", ssh_command);
++
 +    if (git_set_config_value(GIT_CONFIG_CORE_SSHCOMMAND, ssh_command, scope) != 0) {
 +        set_error(ERR_GIT_CONFIG_FAILED, "Failed to set SSH command configuration");
 +        return -1;
 +    }
++
 +    return 0;
 +}
++
 +/* Configure GPG for git operations */
 +int git_configure_gpg(const account_t *account, git_scope_t scope) {
 +    if (!account || !account->gpg_enabled || strlen(account->gpg_key_id) == 0) {
 +        return 0; /* Nothing to configure */
 +    }
++
 +    log_debug("Configuring GPG signing key: %s", account->gpg_key_id);
++
 +    /* Set signing key */
 +    if (git_set_config_value(GIT_CONFIG_USER_SIGNINGKEY, account->gpg_key_id, scope) != 0) {
 +        set_error(ERR_GIT_CONFIG_FAILED, "Failed to set GPG signing key");
 +        return -1;
 +    }
++
 +    /* Enable/disable GPG signing */
 +    if (git_set_config_value(GIT_CONFIG_COMMIT_GPGSIGN,
 +                            account->gpg_signing_enabled ? "true" : "false", scope) != 0) {
 +        set_error(ERR_GIT_CONFIG_FAILED, "Failed to set GPG signing preference");
 +        return -1;
 +    }
++
 +    return 0;
 +}
++
 +/* Check if current directory is a git repository */
 +bool git_is_repository(void) {
 +    char output[256];
++
 +    /* Use git rev-parse --git-dir to check for repository */
 +    if (execute_git_command("rev-parse --git-dir", output, sizeof(output)) == 0) {
 +        return true;
 +    }
++
 +    return false;
 +}
++
 +/* Get repository root directory */
 +int git_get_repo_root(char *path, size_t path_size) {
 +    char output[MAX_PATH_LEN];
++
 +    if (!path || path_size == 0) {
 +        set_error(ERR_INVALID_ARGS, "Invalid arguments to git_get_repo_root");
 +        return -1;
 +    }
++
 +    if (execute_git_command("rev-parse --show-toplevel", output, sizeof(output)) != 0) {
 +        set_error(ERR_GIT_NOT_REPOSITORY, "Not in a git repository");
 +        return -1;
 +    }
++
 +    trim_whitespace(output);
 +    safe_strncpy(path, output, path_size);
++
 +    return 0;
 +}
++
 +/* Convert scope enum to git config scope string */
 +const char *git_scope_to_flag(git_scope_t scope) {
 +    switch (scope) {
 +        case GIT_SCOPE_LOCAL:  return "--local";
 +        case GIT_SCOPE_GLOBAL: return "--global";
 +        case GIT_SCOPE_SYSTEM: return "--system";
 +        default: return NULL;
 +    }
 +}
++
 +/* Internal helper functions */
++
 +/* Execute git command and capture output */
 +static int execute_git_command(const char *args, char *output, size_t output_size) {
 +    char command[1024];
 +    FILE *pipe;
++
 +    if (!args) {
 +        return -1;
 +    }
++
 +    /* Build full git command */
 +    if (snprintf(command, sizeof(command), "git %s 2>&1", args) >= sizeof(command)) {
 +        set_error(ERR_INVALID_ARGS, "Git command too long");
 +        return -1;
 +    }
++
 +    log_debug("Executing git command: %s", command);
++
 +    /* Execute command */
 +    pipe = popen(command, "r");
 +    if (!pipe) {
 +        set_system_error(ERR_SYSTEM_COMMAND_FAILED, "Failed to execute git command");
 +        return -1;
 +    }
++
 +    /* Read output if buffer provided */
 +    if (output && output_size > 0) {
 +        if (!fgets(output, output_size, pipe)) {
 +            output[0] = '\0';
 +        }
 +    }
++
 +    int exit_code = pclose(pipe);
 +    if (exit_code != 0) {
 +        log_debug("Git command failed with exit code: %d", exit_code);
 +        return -1;
 +    }
++
 +    return 0;
 +}
++
 +/* Validate git installation */
 +static int validate_git_installation(void) {
 +    char version_output[256];
++
 +    /* Check if git is available */
 +    if (!command_exists("git")) {
 +        set_error(ERR_SYSTEM_REQUIREMENT, "Git is not installed or not in PATH");
 +        return -1;
 +    }
++
 +    /* Get git version */
 +    if (execute_git_command("--version", version_output, sizeof(version_output)) != 0) {
 +        set_error(ERR_SYSTEM_REQUIREMENT, "Failed to get git version");
 +        return -1;
 +    }
++
 +    log_debug("Git version: %s", version_output);
++
 +    /* Basic version check - require git 2.0+ */
 +    if (!strstr(version_output, "git version ")) {
 +        set_error(ERR_SYSTEM_REQUIREMENT, "Unexpected git version output");
 +        return -1;
 +    }
++
 +    return 0;
 +}
++
 +/* Detect repository scope */
 +static int detect_repository_scope(git_scope_t *detected_scope) {
 +    if (!detected_scope) {
 +        return -1;
 +    }
++
 +    if (git_is_repository()) {
 +        *detected_scope = GIT_SCOPE_LOCAL;
 +    } else {
 +        *detected_scope = GIT_SCOPE_GLOBAL;
 +    }
++
 +    return 0;
 +}
++
 +/* Validate git config value for security */
 +static bool is_valid_git_config_value(const char *value) {
 +    if (!value) {
 +        return false;
 +    }
++
 +    /* Check for dangerous characters */
 +    const char *dangerous_chars = ";|&`$(){}[]";
 +    for (const char *p = dangerous_chars; *p; p++) {
 +        if (strchr(value, *p)) {
 +            return false;
 +        }
 +    }
++
 +    /* Check for control characters */
 +    for (const char *p = value; *p; p++) {
 +        if (*p < 32 && *p != '\t') {
 +            return false;
 +        }
 +    }
++
 +    return true;
 +}
++
 +/* Backup git config if needed */
 +static int backup_git_config_if_needed(git_scope_t scope) {
 +    /* TODO: Implement config backup for safety */
 +    (void)scope; /* Suppress unused parameter warning */
 +    return 0;
 +}
++
 +/* Restore git config if needed */
 +static int restore_git_config_if_needed(git_scope_t scope) {
 +    /* TODO: Implement config restore */
 +    (void)scope; /* Suppress unused parameter warning */
 +    return 0;
 +}

src/gpg_manager.cadded

 +/* GPG key and environment management with comprehensive isolation and security
 + * Implements per-account GNUPGHOME environments to prevent GPG key mixing
 + */
++
 +#define _POSIX_C_SOURCE 200809L
 +#define _DEFAULT_SOURCE
 +#include <stdio.h>
 +#include <stdlib.h>
 +#include <string.h>
 +#include <unistd.h>
 +#include <sys/wait.h>
 +#include <sys/stat.h>
 +#include <signal.h>
 +#include <errno.h>
 +#include <fcntl.h>
++
 +#include "gpg_manager.h"
 +#include "error.h"
 +#include "utils.h"
 +#include "display.h"
 +#include "git_ops.h"
++
 +/* Internal helper functions */
 +static int create_isolated_gnupg_home_dir(const char *gnupg_home);
 +static int execute_gpg_command_in_env(const gpg_config_t *gpg_config,
 +                                       const char *command, char *output, size_t output_size);
 +static int copy_key_from_system_keyring(const gpg_config_t *gpg_config, const char *key_id);
 +static int validate_gnupg_home_permissions(const char *gnupg_home);
 +static int setup_gpg_agent_config(const char *gnupg_home);
++
 +/* Initialize GPG manager with specified mode */
 +int gpg_manager_init(gpg_config_t *gpg_config, gpg_mode_t mode) {
 +    if (!gpg_config) {
 +        set_error(ERR_INVALID_ARGS, "Invalid arguments to gpg_manager_init");
 +        return -1;
 +    }
++
 +    log_debug("Initializing GPG manager with mode: %d", mode);
++
 +    /* Initialize GPG configuration */
 +    memset(gpg_config, 0, sizeof(gpg_config_t));
 +    gpg_config->mode = mode;
 +    gpg_config->signing_enabled = false;
 +    gpg_config->home_owned = false;
++
 +    /* Initialize based on mode */
 +    switch (mode) {
 +        case GPG_MODE_SYSTEM:
 +            /* Use system GNUPGHOME */
 +            log_debug("Using system GPG environment");
 +            break;
++
 +        case GPG_MODE_ISOLATED:
 +            /* Will create isolated GNUPGHOME per account */
 +            log_debug("GPG manager initialized for isolated environments");
 +            break;
++
 +        case GPG_MODE_SHARED:
 +            /* Shared GNUPGHOME with key switching */
 +            log_debug("GPG manager initialized for shared environment");
 +            break;
++
 +        default:
 +            set_error(ERR_INVALID_ARGS, "Invalid GPG mode: %d", mode);
 +            return -1;
 +    }
++
 +    /* Verify GPG is available */
 +    if (!command_exists("gpg")) {
 +        set_error(ERR_GPG_NOT_FOUND, "GPG command not found in PATH");
 +        return -1;
 +    }
++
 +    log_info("GPG manager initialized successfully");
 +    return 0;
 +}
++
 +/* Cleanup GPG manager */
 +void gpg_manager_cleanup(gpg_config_t *gpg_config) {
 +    if (!gpg_config) {
 +        return;
 +    }
++
 +    log_debug("Cleaning up GPG manager");
++
 +    /* Clean up owned GNUPGHOME directory if needed */
 +    if (gpg_config->home_owned && strlen(gpg_config->gnupg_home) > 0) {
 +        log_debug("Cleaning up owned GNUPGHOME: %s", gpg_config->gnupg_home);
++
 +        /* Only remove if it's clearly our isolated directory */
 +        if (strstr(gpg_config->gnupg_home, "gitswitch-gpg") != NULL) {
 +            char command[512];
 +            if (safe_snprintf(command, sizeof(command), "rm -rf '%s'", gpg_config->gnupg_home) == 0) {
 +                if (system(command) != 0) {
 +                    log_warning("Failed to remove GNUPGHOME directory: %s", gpg_config->gnupg_home);
 +                } else {
 +                    log_debug("Successfully removed GNUPGHOME: %s", gpg_config->gnupg_home);
 +                }
 +            }
 +        }
 +    }
++
 +    /* Clear configuration */
 +    memset(gpg_config, 0, sizeof(gpg_config_t));
++
 +    log_debug("GPG manager cleanup completed");
 +}
++
 +/* Switch to account's GPG configuration with complete isolation */
 +int gpg_switch_account(gpg_config_t *gpg_config, const account_t *account) {
 +    if (!gpg_config || !account) {
 +        set_error(ERR_INVALID_ARGS, "Invalid arguments to gpg_switch_account");
 +        return -1;
 +    }
++
 +    /* Skip if GPG not enabled for account */
 +    if (!account->gpg_enabled || strlen(account->gpg_key_id) == 0) {
 +        log_debug("GPG not enabled for account: %s", account->name);
 +        return 0;
 +    }
++
 +    log_info("Switching to GPG configuration for account: %s", account->name);
 +    log_debug("Account GPG key ID: %s", account->gpg_key_id);
++
 +    /* Handle different GPG modes */
 +    switch (gpg_config->mode) {
 +        case GPG_MODE_SYSTEM:
 +            /* Just validate key exists in system keyring */
 +            if (gpg_validate_key(gpg_config, account->gpg_key_id) != 0) {
 +                set_error(ERR_GPG_KEY_NOT_FOUND, "GPG key not found in system keyring: %s",
 +                         account->gpg_key_id);
 +                return -1;
 +            }
 +            break;
++
 +        case GPG_MODE_ISOLATED:
 +            /* Create isolated GNUPGHOME for account */
 +            if (gpg_create_isolated_home(gpg_config, account) != 0) {
 +                set_error(ERR_GPG_KEY_FAILED, "Failed to create isolated GPG environment: %s",
 +                         get_last_error()->message);
 +                return -1;
 +            }
++
 +            /* Copy key from system keyring to isolated environment */
 +            if (copy_key_from_system_keyring(gpg_config, account->gpg_key_id) != 0) {
 +                log_warning("Failed to copy GPG key to isolated environment: %s",
 +                           get_last_error()->message);
 +                /* Continue anyway - maybe key is already there */
 +            }
++
 +            /* Validate key is available in isolated environment */
 +            if (gpg_validate_key(gpg_config, account->gpg_key_id) != 0) {
 +                set_error(ERR_GPG_KEY_NOT_FOUND, "GPG key not available in isolated environment: %s",
 +                         account->gpg_key_id);
 +                return -1;
 +            }
 +            break;
++
 +        case GPG_MODE_SHARED:
 +            /* Validate key exists and switch to it */
 +            if (gpg_validate_key(gpg_config, account->gpg_key_id) != 0) {
 +                set_error(ERR_GPG_KEY_NOT_FOUND, "GPG key not found: %s", account->gpg_key_id);
 +                return -1;
 +            }
 +            break;
++
 +        default:
 +            set_error(ERR_INVALID_ARGS, "Invalid GPG mode: %d", gpg_config->mode);
 +            return -1;
 +    }
++
 +    /* Update GPG configuration */
 +    safe_strncpy(gpg_config->current_key_id, account->gpg_key_id, sizeof(gpg_config->current_key_id));
 +    gpg_config->signing_enabled = account->gpg_signing_enabled;
++
 +    /* Set environment variable if using isolated mode */
 +    if (gpg_config->mode == GPG_MODE_ISOLATED) {
 +        if (gpg_set_environment(gpg_config) != 0) {
 +            log_warning("Failed to set GPG environment variable: %s", get_last_error()->message);
 +        }
 +    }
++
 +    /* Test GPG signing if enabled */
 +    if (account->gpg_signing_enabled) {
 +        if (gpg_test_signing(gpg_config, account->gpg_key_id) != 0) {
 +            log_warning("GPG signing test failed for key: %s", account->gpg_key_id);
 +            /* Don't fail completely, just warn */
 +        } else {
 +            log_info("GPG signing test passed for key: %s", account->gpg_key_id);
 +        }
 +    }
++
 +    log_info("Successfully switched to GPG configuration for account: %s", account->name);
 +    return 0;
 +}
++
 +/* Create isolated GNUPGHOME for account */
 +int gpg_create_isolated_home(gpg_config_t *gpg_config, const account_t *account) {
 +    char gnupg_base_dir[MAX_PATH_LEN];
 +    char gnupg_home[MAX_PATH_LEN];
 +    const char *home_dir;
 +    const char *runtime_dir;
++
 +    if (!gpg_config || !account) {
 +        set_error(ERR_INVALID_ARGS, "Invalid arguments to gpg_create_isolated_home");
 +        return -1;
 +    }
++
 +    /* Determine base directory for isolated GNUPGHOME */
 +    runtime_dir = getenv("XDG_RUNTIME_DIR");
 +    home_dir = getenv("HOME");
++
 +    if (runtime_dir) {
 +        /* Use XDG runtime directory if available */
 +        if (safe_snprintf(gnupg_base_dir, sizeof(gnupg_base_dir), "%s/gitswitch-gpg", runtime_dir) != 0) {
 +            set_error(ERR_INVALID_PATH, "GNUPG base directory path too long");
 +            return -1;
 +        }
 +    } else if (home_dir) {
 +        /* Fall back to home directory */
 +        if (safe_snprintf(gnupg_base_dir, sizeof(gnupg_base_dir), "%s/.local/run/gitswitch-gpg", home_dir) != 0) {
 +            set_error(ERR_INVALID_PATH, "GNUPG base directory path too long");
 +            return -1;
 +        }
 +    } else {
 +        /* Last resort: use /tmp */
 +        if (safe_snprintf(gnupg_base_dir, sizeof(gnupg_base_dir), "/tmp/gitswitch-gpg-%d", getuid()) != 0) {
 +            set_error(ERR_INVALID_PATH, "GNUPG base directory path too long");
 +            return -1;
 +        }
 +    }
++
 +    /* Create base directory */
 +    if (create_directory_recursive(gnupg_base_dir, 0700) != 0) {
 +        set_error(ERR_FILE_IO, "Failed to create GPG base directory: %s", gnupg_base_dir);
 +        return -1;
 +    }
++
 +    /* Create account-specific GNUPGHOME */
 +    if (safe_snprintf(gnupg_home, sizeof(gnupg_home), "%s/%s", gnupg_base_dir, account->name) != 0) {
 +        set_error(ERR_INVALID_PATH, "GNUPGHOME path too long");
 +        return -1;
 +    }
++
 +    /* Create isolated GNUPGHOME directory */
 +    if (create_isolated_gnupg_home_dir(gnupg_home) != 0) {
 +        return -1;
 +    }
++
 +    /* Set up GPG agent configuration */
 +    if (setup_gpg_agent_config(gnupg_home) != 0) {
 +        log_warning("Failed to set up GPG agent config: %s", get_last_error()->message);
 +        /* Continue anyway */
 +    }
++
 +    /* Update GPG configuration */
 +    safe_strncpy(gpg_config->gnupg_home, gnupg_home, sizeof(gpg_config->gnupg_home));
 +    gpg_config->home_owned = true;
++
 +    log_info("Created isolated GNUPGHOME: %s", gnupg_home);
 +    return 0;
 +}
++
 +/* Import GPG key from file or keyserver */
 +int gpg_import_key(gpg_config_t *gpg_config, const char *key_source) {
 +    char command[512];
 +    char output[1024];
 +    int result;
++
 +    if (!gpg_config || !key_source) {
 +        set_error(ERR_INVALID_ARGS, "Invalid arguments to gpg_import_key");
 +        return -1;
 +    }
++
 +    log_debug("Importing GPG key from: %s", key_source);
++
 +    /* Check if key_source is a file or key ID */
 +    if (path_exists(key_source)) {
 +        /* Import from file */
 +        if (safe_snprintf(command, sizeof(command), "gpg --import '%s'", key_source) != 0) {
 +            set_error(ERR_INVALID_ARGS, "GPG import command too long");
 +            return -1;
 +        }
 +    } else {
 +        /* Import from keyserver */
 +        if (safe_snprintf(command, sizeof(command), "gpg --keyserver hkps://keys.openpgp.org --recv-keys %s",
 +                         key_source) != 0) {
 +            set_error(ERR_INVALID_ARGS, "GPG keyserver command too long");
 +            return -1;
 +        }
 +    }
++
 +    /* Execute import command */
 +    result = execute_gpg_command_in_env(gpg_config, command, output, sizeof(output));
 +    if (result != 0) {
 +        set_error(ERR_GPG_KEY_FAILED, "Failed to import GPG key: %s", output);
 +        return -1;
 +    }
++
 +    log_info("Successfully imported GPG key from: %s", key_source);
 +    return 0;
 +}
++
 +/* Export GPG public key for backup/sharing */
 +int gpg_export_public_key(gpg_config_t *gpg_config, const char *key_id,
 +                          char *output, size_t output_size) {
 +    char command[256];
++
 +    if (!gpg_config || !key_id || !output || output_size == 0) {
 +        set_error(ERR_INVALID_ARGS, "Invalid arguments to gpg_export_public_key");
 +        return -1;
 +    }
++
 +    if (safe_snprintf(command, sizeof(command), "gpg --armor --export %s", key_id) != 0) {
 +        set_error(ERR_INVALID_ARGS, "GPG export command too long");
 +        return -1;
 +    }
++
 +    return execute_gpg_command_in_env(gpg_config, command, output, output_size);
 +}
++
 +/* List available GPG keys */
 +int gpg_list_keys(gpg_config_t *gpg_config, char *output, size_t output_size) {
 +    if (!gpg_config || !output || output_size == 0) {
 +        set_error(ERR_INVALID_ARGS, "Invalid arguments to gpg_list_keys");
 +        return -1;
 +    }
++
 +    return execute_gpg_command_in_env(gpg_config, "gpg --list-keys --with-colons", output, output_size);
 +}
++
 +/* Validate GPG key exists and is usable */
 +int gpg_validate_key(gpg_config_t *gpg_config, const char *key_id) {
 +    char command[256];
 +    char output[512];
 +    int result;
++
 +    if (!gpg_config || !key_id) {
 +        set_error(ERR_INVALID_ARGS, "Invalid arguments to gpg_validate_key");
 +        return -1;
 +    }
++
 +    log_debug("Validating GPG key: %s", key_id);
++
 +    /* Check if key exists in keyring */
 +    if (safe_snprintf(command, sizeof(command), "gpg --list-secret-keys %s", key_id) != 0) {
 +        set_error(ERR_INVALID_ARGS, "GPG validation command too long");
 +        return -1;
 +    }
++
 +    result = execute_gpg_command_in_env(gpg_config, command, output, sizeof(output));
 +    if (result != 0) {
 +        set_error(ERR_GPG_KEY_NOT_FOUND, "GPG key not found: %s", key_id);
 +        return -1;
 +    }
++
 +    log_debug("GPG key validation passed: %s", key_id);
 +    return 0;
 +}
++
 +/* Configure git GPG signing */
 +int gpg_configure_git_signing(gpg_config_t *gpg_config, const account_t *account, git_scope_t scope) {
 +    if (!gpg_config || !account) {
 +        set_error(ERR_INVALID_ARGS, "Invalid arguments to gpg_configure_git_signing");
 +        return -1;
 +    }
++
 +    /* Skip if GPG signing not enabled */
 +    if (!account->gpg_signing_enabled) {
 +        log_debug("GPG signing not enabled for account: %s", account->name);
++
 +        /* Disable git signing */
 +        if (git_set_config_value("commit.gpgsign", "false", scope) != 0) {
 +            log_warning("Failed to disable git GPG signing");
 +        }
 +        return 0;
 +    }
++
 +    log_info("Configuring git GPG signing for account: %s", account->name);
++
 +    /* Set signing key */
 +    if (git_set_config_value("user.signingkey", account->gpg_key_id, scope) != 0) {
 +        set_error(ERR_GIT_CONFIG_FAILED, "Failed to set git signing key");
 +        return -1;
 +    }
++
 +    /* Enable GPG signing */
 +    if (git_set_config_value("commit.gpgsign", "true", scope) != 0) {
 +        set_error(ERR_GIT_CONFIG_FAILED, "Failed to enable git GPG signing");
 +        return -1;
 +    }
++
 +    /* Set GPG program if using isolated environment */
 +    if (gpg_config->mode == GPG_MODE_ISOLATED && strlen(gpg_config->gnupg_home) > 0) {
 +        char gpg_command[MAX_PATH_LEN + 50];
 +        if (safe_snprintf(gpg_command, sizeof(gpg_command), "gpg --homedir '%s'", gpg_config->gnupg_home) == 0) {
 +            if (git_set_config_value("gpg.program", gpg_command, scope) != 0) {
 +                log_warning("Failed to set git GPG program");
 +            }
 +        }
 +    }
++
 +    log_info("Git GPG signing configured successfully for account: %s", account->name);
 +    return 0;
 +}
++
 +/* Test GPG signing by creating a test signature */
 +int gpg_test_signing(gpg_config_t *gpg_config, const char *key_id) {
 +    char command[512];
 +    char output[1024];
 +    int result;
++
 +    if (!gpg_config || !key_id) {
 +        set_error(ERR_INVALID_ARGS, "Invalid arguments to gpg_test_signing");
 +        return -1;
 +    }
++
 +    log_debug("Testing GPG signing with key: %s", key_id);
++
 +    /* Create test signature */
 +    if (safe_snprintf(command, sizeof(command),
 +                     "echo 'GPG signing test' | gpg --clearsign --local-user %s", key_id) != 0) {
 +        set_error(ERR_INVALID_ARGS, "GPG test command too long");
 +        return -1;
 +    }
++
 +    result = execute_gpg_command_in_env(gpg_config, command, output, sizeof(output));
 +    if (result != 0) {
 +        set_error(ERR_GPG_SIGNING_FAILED, "GPG signing test failed: %s", output);
 +        return -1;
 +    }
++
 +    /* Verify the signature contains expected content */
 +    if (strstr(output, "BEGIN PGP SIGNED MESSAGE") == NULL) {
 +        set_error(ERR_GPG_SIGNING_FAILED, "GPG signing test produced invalid output");
 +        return -1;
 +    }
++
 +    log_debug("GPG signing test passed for key: %s", key_id);
 +    return 0;
 +}
++
 +/* Generate new GPG key for account */
 +int gpg_generate_key(gpg_config_t *gpg_config, const account_t *account) {
 +    char command[1024];
 +    char key_params[512];
 +    char output[2048];
 +    int result;
++
 +    if (!gpg_config || !account) {
 +        set_error(ERR_INVALID_ARGS, "Invalid arguments to gpg_generate_key");
 +        return -1;
 +    }
++
 +    log_info("Generating new GPG key for account: %s", account->name);
++
 +    /* Create key generation parameters */
 +    if (safe_snprintf(key_params, sizeof(key_params),
 +                     "Key-Type: RSA\n"
 +                     "Key-Length: 4096\n"
 +                     "Subkey-Type: RSA\n"
 +                     "Subkey-Length: 4096\n"
 +                     "Name-Real: %s\n"
 +                     "Name-Email: %s\n"
 +                     "Expire-Date: 2y\n"
 +                     "%%commit\n"
 +                     "%%echo done\n",
 +                     account->name, account->email) != 0) {
 +        set_error(ERR_INVALID_ARGS, "GPG key parameters too long");
 +        return -1;
 +    }
++
 +    /* Generate key */
 +    if (safe_snprintf(command, sizeof(command), "echo '%s' | gpg --batch --generate-key", key_params) != 0) {
 +        set_error(ERR_INVALID_ARGS, "GPG generation command too long");
 +        return -1;
 +    }
++
 +    result = execute_gpg_command_in_env(gpg_config, command, output, sizeof(output));
 +    if (result != 0) {
 +        set_error(ERR_GPG_KEY_FAILED, "Failed to generate GPG key: %s", output);
 +        return -1;
 +    }
++
 +    log_info("Successfully generated GPG key for account: %s", account->name);
 +    return 0;
 +}
++
 +/* Set environment variables for GPG operation */
 +int gpg_set_environment(const gpg_config_t *gpg_config) {
 +    if (!gpg_config) {
 +        set_error(ERR_INVALID_ARGS, "Invalid arguments to gpg_set_environment");
 +        return -1;
 +    }
++
 +    /* Set GNUPGHOME if using isolated mode */
 +    if (gpg_config->mode == GPG_MODE_ISOLATED && strlen(gpg_config->gnupg_home) > 0) {
 +        if (setenv("GNUPGHOME", gpg_config->gnupg_home, 1) != 0) {
 +            set_system_error(ERR_SYSTEM_CALL, "Failed to set GNUPGHOME environment variable");
 +            return -1;
 +        }
++
 +        log_debug("Set GNUPGHOME environment variable: %s", gpg_config->gnupg_home);
 +    }
++
 +    return 0;
 +}
++
 +/* Internal helper functions */
++
 +/* Create isolated GNUPGHOME directory with proper permissions */
 +static int create_isolated_gnupg_home_dir(const char *gnupg_home) {
 +    if (!gnupg_home) {
 +        set_error(ERR_INVALID_ARGS, "NULL gnupg_home path");
 +        return -1;
 +    }
++
 +    /* Create directory with 700 permissions */
 +    if (create_directory_recursive(gnupg_home, 0700) != 0) {
 +        set_error(ERR_FILE_IO, "Failed to create GNUPGHOME directory: %s", gnupg_home);
 +        return -1;
 +    }
++
 +    /* Validate permissions */
 +    if (validate_gnupg_home_permissions(gnupg_home) != 0) {
 +        return -1;
 +    }
++
 +    log_debug("Created isolated GNUPGHOME directory: %s", gnupg_home);
 +    return 0;
 +}
++
 +/* Execute GPG command in specified environment */
 +static int execute_gpg_command_in_env(const gpg_config_t *gpg_config,
 +                                       const char *command, char *output, size_t output_size) {
 +    char full_command[1024];
 +    FILE *fp;
 +    int status;
 +    size_t bytes_read;
++
 +    if (!gpg_config || !command || !output || output_size == 0) {
 +        set_error(ERR_INVALID_ARGS, "Invalid arguments to execute_gpg_command_in_env");
 +        return -1;
 +    }
++
 +    /* Prepare command with GNUPGHOME if needed */
 +    if (gpg_config->mode == GPG_MODE_ISOLATED && strlen(gpg_config->gnupg_home) > 0) {
 +        if (safe_snprintf(full_command, sizeof(full_command),
 +                         "GNUPGHOME='%s' %s 2>&1", gpg_config->gnupg_home, command) != 0) {
 +            set_error(ERR_INVALID_ARGS, "GPG command too long");
 +            return -1;
 +        }
 +    } else {
 +        if (safe_snprintf(full_command, sizeof(full_command), "%s 2>&1", command) != 0) {
 +            set_error(ERR_INVALID_ARGS, "GPG command too long");
 +            return -1;
 +        }
 +    }
++
 +    log_debug("Executing GPG command: %s", full_command);
++
 +    /* Execute command */
 +    fp = popen(full_command, "r");
 +    if (!fp) {
 +        set_system_error(ERR_SYSTEM_COMMAND_FAILED, "Failed to execute GPG command");
 +        return -1;
 +    }
++
 +    /* Read output */
 +    bytes_read = fread(output, 1, output_size - 1, fp);
 +    output[bytes_read] = '\0';
++
 +    status = pclose(fp);
 +    if (status != 0) {
 +        log_debug("GPG command failed with status: %d, output: %s", status, output);
 +        return -1;
 +    }
++
 +    log_debug("GPG command completed successfully");
 +    return 0;
 +}
++
 +/* Copy GPG key from system keyring to isolated environment */
 +static int copy_key_from_system_keyring(const gpg_config_t *gpg_config, const char *key_id) {
 +    char export_command[256];
 +    char import_command[512];
 +    char key_data[8192];
 +    FILE *export_fp, *import_fp;
 +    int export_status, import_status;
 +    size_t bytes_read;
++
 +    if (!gpg_config || !key_id) {
 +        set_error(ERR_INVALID_ARGS, "Invalid arguments to copy_key_from_system_keyring");
 +        return -1;
 +    }
++
 +    log_debug("Copying GPG key from system keyring: %s", key_id);
++
 +    /* Export key from system keyring */
 +    if (safe_snprintf(export_command, sizeof(export_command),
 +                     "gpg --armor --export-secret-keys %s 2>/dev/null", key_id) != 0) {
 +        set_error(ERR_INVALID_ARGS, "Export command too long");
 +        return -1;
 +    }
++
 +    export_fp = popen(export_command, "r");
 +    if (!export_fp) {
 +        set_system_error(ERR_SYSTEM_COMMAND_FAILED, "Failed to export GPG key");
 +        return -1;
 +    }
++
 +    bytes_read = fread(key_data, 1, sizeof(key_data) - 1, export_fp);
 +    key_data[bytes_read] = '\0';
++
 +    export_status = pclose(export_fp);
 +    if (export_status != 0 || bytes_read == 0) {
 +        set_error(ERR_GPG_KEY_NOT_FOUND, "Failed to export GPG key from system keyring");
 +        return -1;
 +    }
++
 +    /* Import key into isolated environment */
 +    if (safe_snprintf(import_command, sizeof(import_command),
 +                     "GNUPGHOME='%s' gpg --batch --import 2>/dev/null", gpg_config->gnupg_home) != 0) {
 +        set_error(ERR_INVALID_ARGS, "Import command too long");
 +        return -1;
 +    }
++
 +    import_fp = popen(import_command, "w");
 +    if (!import_fp) {
 +        set_system_error(ERR_SYSTEM_COMMAND_FAILED, "Failed to start GPG import");
 +        return -1;
 +    }
++
 +    fwrite(key_data, 1, bytes_read, import_fp);
 +    import_status = pclose(import_fp);
++
 +    if (import_status != 0) {
 +        set_error(ERR_GPG_KEY_FAILED, "Failed to import GPG key into isolated environment");
 +        return -1;
 +    }
++
 +    log_info("Successfully copied GPG key to isolated environment: %s", key_id);
 +    return 0;
 +}
++
 +/* Validate GNUPGHOME directory permissions */
 +static int validate_gnupg_home_permissions(const char *gnupg_home) {
 +    mode_t dir_mode;
++
 +    if (!gnupg_home) {
 +        set_error(ERR_INVALID_ARGS, "NULL gnupg_home path");
 +        return -1;
 +    }
++
 +    if (get_file_permissions(gnupg_home, &dir_mode) != 0) {
 +        set_error(ERR_FILE_IO, "Failed to check GNUPGHOME permissions: %s", gnupg_home);
 +        return -1;
 +    }
++
 +    /* Check for 700 permissions */
 +    if ((dir_mode & 0777) != 0700) {
 +        set_error(ERR_PERMISSION_DENIED, "GNUPGHOME has insecure permissions: %o", dir_mode & 0777);
 +        return -1;
 +    }
++
 +    log_debug("GNUPGHOME permissions validated: %s", gnupg_home);
 +    return 0;
 +}
++
 +/* Set up GPG agent configuration for isolated environment */
 +static int setup_gpg_agent_config(const char *gnupg_home) {
 +    char gpg_agent_conf_path[MAX_PATH_LEN];
 +    FILE *conf_file;
++
 +    if (!gnupg_home) {
 +        set_error(ERR_INVALID_ARGS, "NULL gnupg_home path");
 +        return -1;
 +    }
++
 +    /* Create gpg-agent.conf path */
 +    if (safe_snprintf(gpg_agent_conf_path, sizeof(gpg_agent_conf_path),
 +                     "%s/gpg-agent.conf", gnupg_home) != 0) {
 +        set_error(ERR_INVALID_PATH, "GPG agent config path too long");
 +        return -1;
 +    }
++
 +    /* Create basic gpg-agent.conf */
 +    conf_file = fopen(gpg_agent_conf_path, "w");
 +    if (!conf_file) {
 +        set_system_error(ERR_FILE_IO, "Failed to create gpg-agent.conf");
 +        return -1;
 +    }
++
 +    fprintf(conf_file, "# GPG Agent configuration for gitswitch isolated environment\n");
 +    fprintf(conf_file, "default-cache-ttl 3600\n");
 +    fprintf(conf_file, "max-cache-ttl 7200\n");
 +    fprintf(conf_file, "pinentry-program /usr/bin/pinentry-curses\n");
++
 +    fclose(conf_file);
++
 +    /* Set proper permissions */
 +    if (chmod(gpg_agent_conf_path, 0600) != 0) {
 +        set_system_error(ERR_PERMISSION_DENIED, "Failed to set gpg-agent.conf permissions");
 +        return -1;
 +    }
++
 +    log_debug("Created GPG agent configuration: %s", gpg_agent_conf_path);
 +    return 0;
 +}

src/main.cadded

 +/* gitswitch-c: Safe git identity switching with SSH/GPG isolation
 + * Phase 2: Configuration Management - Full CLI with account management
 + */
++
 +#include <stdio.h>
 +#include <stdlib.h>
 +#include <string.h>
 +#include <ctype.h>
 +#include <getopt.h>
 +#include <unistd.h>
++
 +#include "gitswitch.h"
 +#include "config.h"
 +#include "accounts.h"
 +#include "display.h"
 +#include "error.h"
 +#include "utils.h"
++
 +static void print_usage(const char *prog_name) {
 +    printf("Usage: %s [OPTIONS] [COMMAND] [ARGS]\n", prog_name);
 +    printf("\nPhase 5: Complete Authentication Isolation\n");
 +    printf("Safe git identity switching with actual git configuration management\n");
 +    printf("\nCommands:\n");
 +    printf("  add                  Add new account interactively\n");
 +    printf("  list, ls             List all configured accounts\n");
 +    printf("  remove <account>     Remove specified account\n");
 +    printf("  status               Show current account status\n");
 +    printf("  doctor, health       Run comprehensive health check\n");
 +    printf("  config               Show configuration file information\n");
 +    printf("  <account>            Switch to specified account\n");
 +    printf("\nOptions:\n");
 +    printf("  --global, -g         Use global git scope\n");
 +    printf("  --local, -l          Use local git scope (default)\n");
 +    printf("  --dry-run, -n        Show what would be done without executing\n");
 +    printf("  --verbose, -V        Enable verbose output\n");
 +    printf("  --debug, -d          Enable debug logging\n");
 +    printf("  --color, -c          Force color output\n");
 +    printf("  --no-color, -C       Disable color output\n");
 +    printf("  --help, -h           Show this help message\n");
 +    printf("  --version, -v        Show version information\n");
 +    printf("\nExamples:\n");
 +    printf("  %s add                    # Add new account interactively\n", prog_name);
 +    printf("  %s list                   # List all accounts\n", prog_name);
 +    printf("  %s 1                      # Switch to account ID 1\n", prog_name);
 +    printf("  %s work                   # Switch to account matching 'work'\n", prog_name);
 +    printf("  %s remove 2               # Remove account ID 2\n", prog_name);
 +    printf("  %s doctor                 # Run health check\n", prog_name);
 +    printf("\nPhase 3 Features:\n");
 +    printf("- Secure TOML configuration management\n");
 +    printf("- Interactive account creation with validation\n");
 +    printf("- Comprehensive account health checking\n");
 +    printf("- SSH/GPG key validation and security checks\n");
 +    printf("- Atomic configuration file operations\n");
 +    printf("- Safe file permission handling\n");
 +    printf("- Actual git configuration switching\n");
 +    printf("- Repository detection and scope management\n");
 +    printf("- Git configuration validation and testing\n");
 +}
 +static void print_version(void) {
 +    printf("%s version %s (Phase 5: Complete Authentication Isolation)\n", GITSWITCH_NAME, GITSWITCH_VERSION);
 +    printf("Safe git identity switching with SSH/GPG isolation\n");
 +    printf("Built with security and reliability in mind\n\n");
 +    printf("Phase 2 Features [COMPLETE]:\n");
 +    printf("- [DONE] Comprehensive error handling and logging\n");
 +    printf("- [DONE] Security-focused utility functions\n");
 +    printf("- [DONE] Terminal display with color support\n");
 +    printf("- [DONE] Custom secure TOML parser\n");
 +    printf("- [DONE] Configuration management with validation\n");
 +    printf("- [DONE] Interactive account creation and management\n");
 +    printf("- [DONE] SSH/GPG key validation and security checks\n");
 +    printf("- [DONE] Comprehensive health checking system\n");
 +    printf("- [DONE] Atomic file operations with backups\n");
 +    printf("\nPhase 3 Features [COMPLETE]:\n");
 +    printf("- [DONE] Git operations and configuration management\n");
 +    printf("- [DONE] Repository detection and scope handling\n");
 +    printf("- [DONE] Git configuration testing and validation\n");
 +    printf("- [DONE] Actual account switching with git integration\n");
 +    printf("- [DONE] Local vs global scope automatic detection\n");
 +    printf("- [DONE] Git configuration validation and verification\n");
 +    printf("\nPhase 4 Features [COMPLETE]:\n");
 +    printf("- [DONE] Isolated SSH agents per account\n");
 +    printf("- [DONE] SSH agent lifecycle management\n");
 +    printf("- [DONE] SSH key loading and validation\n");
 +    printf("- [DONE] SSH connection testing and isolation\n");
 +    printf("- [DONE] Per-account SSH environment isolation\n");
 +    printf("- [DONE] Secure SSH agent socket management\n");
 +    printf("\nPhase 5 Features [COMPLETE]:\n");
 +    printf("- [DONE] Isolated GPG environments with GNUPGHOME per account\n");
 +    printf("- [DONE] Complete GPG signing and key management\n");
 +    printf("- [DONE] GPG key import/export and validation\n");
 +    printf("- [DONE] Git GPG signing configuration\n");
 +    printf("- [DONE] GPG environment isolation and cleanup\n");
 +    printf("- [DONE] Production-ready authentication isolation\n");
 +    printf("\n[COMPLETE]: All phases implemented!\n");
 +    printf("gitswitch-c provides complete SSH/GPG authentication isolation\n");
 +}
 +static int handle_add_command(gitswitch_ctx_t *ctx);
 +static int handle_list_command(gitswitch_ctx_t *ctx);
 +static int handle_remove_command(gitswitch_ctx_t *ctx, const char *identifier);
 +static int handle_status_command(gitswitch_ctx_t *ctx);
 +static int handle_switch_command(gitswitch_ctx_t *ctx, const char *identifier);
 +static int handle_doctor_command(gitswitch_ctx_t *ctx);
 +static int handle_config_command(gitswitch_ctx_t *ctx);
++
 +int main(int argc, char *argv[]) {
 +    gitswitch_ctx_t ctx;
 +    int opt;
 +    bool force_color = false;
 +    bool no_color = false;
 +    bool show_help = false;
 +    bool show_version = false;
 +    bool dry_run = false;
 +    int exit_code = EXIT_SUCCESS;
++
 +    static struct option long_options[] = {
 +        {"help", no_argument, 0, 'h'},
 +        {"version", no_argument, 0, 'v'},
 +        {"color", no_argument, 0, 'c'},
 +        {"no-color", no_argument, 0, 'C'},
 +        {"verbose", no_argument, 0, 'V'},
 +        {"debug", no_argument, 0, 'd'},
 +        {"dry-run", no_argument, 0, 'n'},
 +        {"global", no_argument, 0, 'g'},
 +        {"local", no_argument, 0, 'l'},
 +        {0, 0, 0, 0}
 +    };
++
 +    /* Initialize error handling */
 +    if (error_init(LOG_LEVEL_INFO, NULL) != 0) {
 +        fprintf(stderr, "Failed to initialize error handling\n");
 +        return EXIT_FAILURE;
 +    }
++
 +    /* Parse command line options */
 +    while ((opt = getopt_long(argc, argv, "hvccVdngl", long_options, NULL)) != -1) {
 +        switch (opt) {
 +            case 'h':
 +                show_help = true;
 +                break;
 +            case 'v':
 +                show_version = true;
 +                break;
 +            case 'c':
 +                force_color = true;
 +                break;
 +            case 'C':
 +                no_color = true;
 +                break;
 +            case 'V':
 +            case 'd':
 +                set_log_level(LOG_LEVEL_DEBUG);
 +                break;
 +            case 'n':
 +                dry_run = true;
 +                break;
 +            case 'g':
 +                /* Global scope - will be handled by command handlers */
 +                break;
 +            case 'l':
 +                /* Local scope - will be handled by command handlers */
 +                break;
 +            default:
 +                print_usage(argv[0]);
 +                error_cleanup();
 +                return EXIT_FAILURE;
 +        }
 +    }
++
 +    /* Initialize display system */
 +    if (display_init(force_color, no_color) != 0) {
 +        log_error("Failed to initialize display system");
 +        error_cleanup();
 +        return EXIT_FAILURE;
 +    }
++
 +    /* Handle special commands that don't need config */
 +    if (show_version) {
 +        print_version();
 +        error_cleanup();
 +        return EXIT_SUCCESS;
 +    }
++
 +    if (show_help) {
 +        print_usage(argv[0]);
 +        error_cleanup();
 +        return EXIT_SUCCESS;
 +    }
++
 +    /* Initialize configuration system */
 +    log_info("Initializing gitswitch-c configuration system");
 +    if (config_init(&ctx) != 0) {
 +        display_error("Configuration initialization failed", get_last_error()->message);
 +        error_cleanup();
 +        return EXIT_CONFIG_ERROR;
 +    }
++
 +    /* Set dry run mode if requested */
 +    ctx.config.dry_run = dry_run;
 +    ctx.config.verbose = (get_last_error() != NULL && should_log(LOG_LEVEL_DEBUG));
++
 +    /* Parse command and arguments */
 +    const char *command = NULL;
 +    const char *arg1 = NULL;
++
 +    if (optind < argc) {
 +        command = argv[optind];
 +        if (optind + 1 < argc) {
 +            arg1 = argv[optind + 1];
 +        }
 +    }
++
 +    /* Execute command */
 +    if (command == NULL) {
 +        /* No command specified - interactive mode or help */
 +        if (ctx.account_count == 0) {
 +            display_header("Welcome to gitswitch-c");
 +            display_warning("No accounts configured yet");
 +            printf("\nTo get started:\n");
 +            printf("  1. Run 'gitswitch add' to create your first account\n");
 +            printf("  2. Run 'gitswitch list' to see all accounts\n");
 +            printf("  3. Run 'gitswitch <account>' to switch accounts\n");
 +            printf("  4. Run 'gitswitch --help' for more options\n\n");
 +        } else {
 +            /* Show account list */
 +            exit_code = handle_list_command(&ctx);
 +        }
 +    } else if (strcmp(command, "add") == 0) {
 +        exit_code = handle_add_command(&ctx);
 +    } else if (strcmp(command, "list") == 0 || strcmp(command, "ls") == 0) {
 +        exit_code = handle_list_command(&ctx);
 +    } else if (strcmp(command, "remove") == 0 || strcmp(command, "rm") == 0 || strcmp(command, "delete") == 0) {
 +        if (!arg1) {
 +            display_error("Missing account identifier", "Usage: gitswitch remove <account>");
 +            exit_code = EXIT_FAILURE;
 +        } else {
 +            exit_code = handle_remove_command(&ctx, arg1);
 +        }
 +    } else if (strcmp(command, "status") == 0) {
 +        exit_code = handle_status_command(&ctx);
 +    } else if (strcmp(command, "doctor") == 0 || strcmp(command, "health") == 0) {
 +        exit_code = handle_doctor_command(&ctx);
 +    } else if (strcmp(command, "config") == 0) {
 +        exit_code = handle_config_command(&ctx);
 +    } else {
 +        /* Assume it's an account identifier for switching */
 +        exit_code = handle_switch_command(&ctx, command);
 +    }
++
 +    /* Save configuration if it was modified and no errors occurred */
 +    if (exit_code == EXIT_SUCCESS && !dry_run) {
 +        if (config_save(&ctx, ctx.config.config_path) != 0) {
 +            display_warning("Failed to save configuration changes");
 +            /* Don't fail the command, just warn */
 +        }
 +    }
++
 +    /* Cleanup */
 +    error_cleanup();
 +    return exit_code == EXIT_SUCCESS ? EXIT_SUCCESS : EXIT_FAILURE;
 +}
++
 +/* Command handler implementations */
++
 +static int handle_add_command(gitswitch_ctx_t *ctx) {
 +    if (!ctx) return EXIT_FAILURE;
++
 +    if (accounts_add_interactive(ctx) != 0) {
 +        display_error("Failed to add account", get_last_error()->message);
 +        return EXIT_FAILURE;
 +    }
++
 +    return EXIT_SUCCESS;
 +}
++
 +static int handle_list_command(gitswitch_ctx_t *ctx) {
 +    if (!ctx) return EXIT_FAILURE;
++
 +    return accounts_list(ctx) == 0 ? EXIT_SUCCESS : EXIT_FAILURE;
 +}
++
 +static int handle_remove_command(gitswitch_ctx_t *ctx, const char *identifier) {
 +    if (!ctx || !identifier) return EXIT_FAILURE;
++
 +    if (accounts_remove(ctx, identifier) != 0) {
 +        display_error("Failed to remove account", get_last_error()->message);
 +        return EXIT_FAILURE;
 +    }
++
 +    return EXIT_SUCCESS;
 +}
++
 +static int handle_status_command(gitswitch_ctx_t *ctx) {
 +    if (!ctx) return EXIT_FAILURE;
++
 +    return accounts_show_status(ctx) == 0 ? EXIT_SUCCESS : EXIT_FAILURE;
 +}
++
 +static int handle_switch_command(gitswitch_ctx_t *ctx, const char *identifier) {
 +    if (!ctx || !identifier) return EXIT_FAILURE;
++
 +    if (ctx->config.dry_run) {
 +        display_info("DRY RUN MODE - No actual changes will be made");
 +    }
++
 +    if (accounts_switch(ctx, identifier) != 0) {
 +        display_error("Failed to switch account", get_last_error()->message);
 +        return EXIT_FAILURE;
 +    }
++
 +    display_success("Successfully switched to account: %s", ctx->current_account->name);
++
 +    return EXIT_SUCCESS;
 +}
++
 +static int handle_doctor_command(gitswitch_ctx_t *ctx) {
 +    if (!ctx) return EXIT_FAILURE;
++
 +    /* Check system requirements */
 +    printf("[INFO]: Checking system requirements...\n");
++
 +    if (command_exists("git")) {
 +        display_success("Git command found");
 +    } else {
 +        display_error("Git not found", "Please install git to use gitswitch");
 +        return EXIT_FAILURE;
 +    }
++
 +    if (command_exists("ssh-agent")) {
 +        display_success("SSH agent found");
 +    } else {
 +        display_warning("SSH agent not found - SSH key management may not work");
 +    }
++
 +    if (command_exists("gpg") || command_exists("gpg2")) {
 +        display_success("GPG found");
 +    } else {
 +        display_warning("GPG not found - GPG signing will not work");
 +    }
++
 +    /* Check configuration */
 +    printf("\n[INFO]: Checking configuration...\n");
++
 +    if (config_validate(ctx) == 0) {
 +        display_success("Configuration validation passed");
 +    } else {
 +        display_error("Configuration validation failed", get_last_error()->message);
 +        return EXIT_FAILURE;
 +    }
++
 +    /* Check all accounts */
 +    return accounts_health_check(ctx) == 0 ? EXIT_SUCCESS : EXIT_FAILURE;
 +}
++
 +static int handle_config_command(gitswitch_ctx_t *ctx) {
 +    if (!ctx) return EXIT_FAILURE;
++
 +    printf("📁 Configuration file: %s\n", ctx->config.config_path);
++
 +    if (!path_exists(ctx->config.config_path)) {
 +        display_warning("Configuration file does not exist");
 +        printf("Create default configuration? (y/N): ");
 +        fflush(stdout);
++
 +        char input[64];
 +        if (fgets(input, sizeof(input), stdin)) {
 +            input[strcspn(input, "\n")] = '\0';
 +            trim_whitespace(input);
++
 +            if (tolower(input[0]) == 'y') {
 +                if (config_create_default(ctx->config.config_path) == 0) {
 +                    display_success("Default configuration created");
 +                    printf("Please edit the file to add your accounts.\n");
 +                } else {
 +                    display_error("Failed to create default configuration", get_last_error()->message);
 +                    return EXIT_FAILURE;
 +                }
 +            }
 +        }
 +        return EXIT_SUCCESS;
 +    }
++
 +    /* Show configuration info */
 +    printf("Accounts: %zu configured\n", ctx->account_count);
 +    printf("Default scope: %s\n", config_scope_to_string(ctx->config.default_scope));
++
 +    /* Check permissions */
 +    mode_t file_mode;
 +    if (get_file_permissions(ctx->config.config_path, &file_mode) == 0) {
 +        if ((file_mode & 077) == 0) {
 +            display_success("Configuration file permissions are secure (600)");
 +        } else {
 +            display_warning("Configuration file has unsafe permissions (%o)", file_mode & 0777);
 +        }
 +    }
++
 +    return EXIT_SUCCESS;
 +}
++

src/main_simple.cadded

 +/* gitswitch-c: Safe git identity switching with SSH/GPG isolation
 + * Simplified Phase 1 implementation for foundation testing
 + */
++
 +#include <stdio.h>
 +#include <stdlib.h>
 +#include <string.h>
 +#include <getopt.h>
 +#include <unistd.h>
++
 +#include "gitswitch.h"
 +#include "error.h"
++
 +static void print_usage(const char *prog_name);
 +static void print_version(void);
++
 +int main(int argc, char *argv[]) {
 +    int opt;
 +    bool show_help = false;
 +    bool show_version = false;
 +    bool verbose = false;
++
 +    static struct option long_options[] = {
 +        {"help", no_argument, 0, 'h'},
 +        {"version", no_argument, 0, 'v'},
 +        {"verbose", no_argument, 0, 'V'},
 +        {0, 0, 0, 0}
 +    };
++
 +    /* Initialize error handling */
 +    if (error_init(LOG_LEVEL_INFO, NULL) != 0) {
 +        fprintf(stderr, "Failed to initialize error handling\n");
 +        return EXIT_FAILURE;
 +    }
++
 +    /* Parse command line options */
 +    while ((opt = getopt_long(argc, argv, "hvV", long_options, NULL)) != -1) {
 +        switch (opt) {
 +            case 'h':
 +                show_help = true;
 +                break;
 +            case 'v':
 +                show_version = true;
 +                break;
 +            case 'V':
 +                verbose = true;
 +                set_log_level(LOG_LEVEL_DEBUG);
 +                break;
 +            default:
 +                print_usage(argv[0]);
 +                error_cleanup();
 +                return EXIT_FAILURE;
 +        }
 +    }
++
 +    /* Handle special commands */
 +    if (show_version) {
 +        print_version();
 +        error_cleanup();
 +        return EXIT_SUCCESS;
 +    }
++
 +    if (show_help) {
 +        print_usage(argv[0]);
 +        error_cleanup();
 +        return EXIT_SUCCESS;
 +    }
++
 +    /* Phase 1 demonstration */
 +    printf("┌──────────────────────────────────────┐\n");
 +    printf("│   gitswitch-c Phase 1 Foundation    │\n");
 +    printf("└──────────────────────────────────────┘\n\n");
++
 +    printf("✓ Error handling system: initialized\n");
 +    printf("✓ Build system: working\n");
 +    printf("✓ Command line parsing: functional\n");
++
 +    if (verbose) {
 +        log_info("Verbose mode enabled");
 +        log_debug("Debug logging active");
 +    }
++
 +    /* Test error handling */
 +    printf("\nTesting error handling:\n");
 +    set_error(ERR_SUCCESS, "This is a test success message");
 +    const error_context_t *err = get_last_error();
 +    if (err->code == ERR_SUCCESS) {
 +        printf("✓ Error context system working\n");
 +    }
++
 +    printf("\nPhase 1 foundation is solid! ✨\n");
 +    printf("Ready for Phase 2: Configuration management\n\n");
++
 +    /* Cleanup */
 +    error_cleanup();
 +    return EXIT_SUCCESS;
 +}
++
 +static void print_usage(const char *prog_name) {
 +    printf("Usage: %s [OPTIONS] [COMMAND] [ARGS]\n", prog_name);
 +    printf("\nThis is a Phase 1 development build of gitswitch-c\n");
 +    printf("Safe git identity switching with SSH/GPG isolation\n\n");
 +    printf("Options:\n");
 +    printf("  --help, -h           Show this help message\n");
 +    printf("  --version, -v        Show version information\n");
 +    printf("  --verbose, -V        Enable verbose output\n\n");
 +    printf("Phase 1 Status:\n");
 +    printf("  ✓ Error handling system\n");
 +    printf("  ✓ Build system\n");
 +    printf("  ✓ Command line parsing\n");
 +    printf("  • Configuration management (Phase 2)\n");
 +    printf("  • Git operations (Phase 3)\n");
 +    printf("  • SSH security framework (Phase 4)\n");
 +    printf("  • GPG security framework (Phase 5)\n");
 +    printf("  • Full CLI integration (Phase 6)\n");
 +}
++
 +static void print_version(void) {
 +    printf("%s version %s (Phase 1 Development Build)\n", GITSWITCH_NAME, GITSWITCH_VERSION);
 +    printf("Safe git identity switching with SSH/GPG isolation\n");
 +    printf("Built with security and reliability in mind\n\n");
 +    printf("Phase 1 Features:\n");
 +    printf("• Comprehensive error handling and logging\n");
 +    printf("• Security-focused utility functions\n");
 +    printf("• Foundation for SSH/GPG isolation\n");
 +    printf("• Robust build system with hardening\n\n");
 +    printf("Upcoming Features:\n");
 +    printf("• Isolated SSH agents per account\n");
 +    printf("• Separate GPG environments\n");
 +    printf("• Comprehensive validation\n");
 +    printf("• Secure memory handling\n");
 +}

src/ssh_manager.cadded

 +/* SSH key and agent management with comprehensive isolation and security
 + * Implements per-account SSH agents to prevent key leakage between accounts
 + */
++
 +#define _POSIX_C_SOURCE 200809L
 +#define _DEFAULT_SOURCE
 +#include <stdio.h>
 +#include <stdlib.h>
 +#include <string.h>
 +#include <unistd.h>
 +#include <sys/wait.h>
 +#include <sys/stat.h>
 +#include <signal.h>
 +#include <errno.h>
 +#include <fcntl.h>
++
 +#include "ssh_manager.h"
 +#include "error.h"
 +#include "utils.h"
 +#include "display.h"
++
 +/* Internal helper functions */
 +static int execute_ssh_command(const char *command, char *output, size_t output_size);
 +static int setup_ssh_environment(ssh_config_t *ssh_config);
 +static int create_isolated_agent_socket_dir(char *socket_dir, size_t socket_dir_size);
 +static bool is_ssh_agent_running(pid_t pid);
 +static int kill_ssh_agent_gracefully(pid_t pid);
 +static int validate_ssh_agent_socket(const char *socket_path);
 +static int parse_ssh_agent_output(const char *output, ssh_config_t *ssh_config);
++
 +/* Global SSH configuration for cleanup */
 +static ssh_config_t *g_active_ssh_config = NULL;
++
 +/* Initialize SSH manager */
 +int ssh_manager_init(ssh_config_t *ssh_config, ssh_agent_mode_t mode) {
 +    if (!ssh_config) {
 +        set_error(ERR_INVALID_ARGS, "NULL ssh_config to ssh_manager_init");
 +        return -1;
 +    }
++
 +    log_debug("Initializing SSH manager with mode: %d", mode);
++
 +    /* Initialize structure */
 +    memset(ssh_config, 0, sizeof(ssh_config_t));
 +    ssh_config->mode = mode;
 +    ssh_config->agent_pid = -1;
 +    ssh_config->agent_owned = false;
++
 +    /* Validate SSH is available */
 +    if (!command_exists("ssh")) {
 +        set_error(ERR_SSH_NOT_FOUND, "SSH command not found in PATH");
 +        return -1;
 +    }
++
 +    if (!command_exists("ssh-agent")) {
 +        set_error(ERR_SSH_AGENT_NOT_FOUND, "ssh-agent command not found in PATH");
 +        return -1;
 +    }
++
 +    if (!command_exists("ssh-add")) {
 +        set_error(ERR_SSH_AGENT_NOT_FOUND, "ssh-add command not found in PATH");
 +        return -1;
 +    }
++
 +    /* Set up based on mode */
 +    switch (mode) {
 +        case SSH_AGENT_SYSTEM:
 +            /* Use existing SSH_AUTH_SOCK */
 +            if (getenv("SSH_AUTH_SOCK")) {
 +                safe_strncpy(ssh_config->agent_socket_path, getenv("SSH_AUTH_SOCK"),
 +                           sizeof(ssh_config->agent_socket_path));
 +                log_info("Using system SSH agent at: %s", ssh_config->agent_socket_path);
 +            } else {
 +                log_warning("No system SSH agent found (SSH_AUTH_SOCK not set)");
 +            }
 +            break;
++
 +        case SSH_AGENT_ISOLATED:
 +            /* Will create isolated agents on demand */
 +            log_info("Initialized for isolated SSH agent mode");
 +            break;
++
 +        case SSH_AGENT_NONE:
 +            log_info("SSH agent management disabled");
 +            break;
++
 +        default:
 +            set_error(ERR_INVALID_ARGS, "Invalid SSH agent mode: %d", mode);
 +            return -1;
 +    }
++
 +    /* Register for cleanup */
 +    g_active_ssh_config = ssh_config;
++
 +    log_info("SSH manager initialized successfully");
 +    return 0;
 +}
++
 +/* Cleanup SSH manager */
 +void ssh_manager_cleanup(ssh_config_t *ssh_config) {
 +    if (!ssh_config) {
 +        return;
 +    }
++
 +    log_debug("Cleaning up SSH manager");
++
 +    /* Stop agent if we own it */
 +    if (ssh_config->agent_owned && ssh_config->agent_pid > 0) {
 +        log_info("Stopping owned SSH agent (PID: %d)", ssh_config->agent_pid);
 +        ssh_stop_agent(ssh_config);
 +    }
++
 +    /* Clear global reference */
 +    if (g_active_ssh_config == ssh_config) {
 +        g_active_ssh_config = NULL;
 +    }
++
 +    /* Clear sensitive data */
 +    secure_zero_memory(ssh_config, sizeof(ssh_config_t));
++
 +    log_debug("SSH manager cleanup complete");
 +}
++
 +/* Switch to account's SSH configuration */
 +int ssh_switch_account(ssh_config_t *ssh_config, const account_t *account) {
 +    char expanded_key_path[MAX_PATH_LEN];
++
 +    if (!ssh_config || !account) {
 +        set_error(ERR_INVALID_ARGS, "Invalid arguments to ssh_switch_account");
 +        return -1;
 +    }
++
 +    /* Skip if SSH not enabled for this account */
 +    if (!account->ssh_enabled || strlen(account->ssh_key_path) == 0) {
 +        log_debug("SSH not enabled for account: %s", account->name);
 +        return 0;
 +    }
++
 +    log_info("Switching SSH configuration for account: %s", account->name);
++
 +    /* Validate and expand key path */
 +    if (expand_path(account->ssh_key_path, expanded_key_path, sizeof(expanded_key_path)) != 0) {
 +        set_error(ERR_INVALID_PATH, "Failed to expand SSH key path: %s", account->ssh_key_path);
 +        return -1;
 +    }
++
 +    /* Validate key file */
 +    if (ssh_validate_key_file(expanded_key_path) != 0) {
 +        return -1; /* Error already set */
 +    }
++
 +    /* Handle based on mode */
 +    switch (ssh_config->mode) {
 +        case SSH_AGENT_SYSTEM:
 +            /* Clear existing keys and add new one to system agent */
 +            if (strlen(ssh_config->agent_socket_path) > 0) {
 +                log_debug("Clearing system SSH agent keys");
 +                ssh_clear_agent_keys(ssh_config);
++
 +                log_debug("Adding key to system SSH agent: %s", expanded_key_path);
 +                if (ssh_add_key(ssh_config, expanded_key_path) != 0) {
 +                    set_error(ERR_SSH_KEY_LOAD_FAILED, "Failed to load key into system SSH agent");
 +                    return -1;
 +                }
 +            } else {
 +                log_warning("No system SSH agent available");
 +            }
 +            break;
++
 +        case SSH_AGENT_ISOLATED:
 +            /* Start isolated agent for this account */
 +            if (ssh_start_isolated_agent(ssh_config, account) != 0) {
 +                return -1; /* Error already set */
 +            }
++
 +            /* Add key to isolated agent */
 +            if (ssh_add_key(ssh_config, expanded_key_path) != 0) {
 +                set_error(ERR_SSH_KEY_LOAD_FAILED, "Failed to load key into isolated SSH agent");
 +                return -1;
 +            }
 +            break;
++
 +        case SSH_AGENT_NONE:
 +            /* No agent management - just validate key */
 +            log_info("SSH agent management disabled - key validated but not loaded");
 +            break;
++
 +        default:
 +            set_error(ERR_INVALID_ARGS, "Invalid SSH agent mode");
 +            return -1;
 +    }
++
 +    /* Configure host alias if specified */
 +    if (strlen(account->ssh_host_alias) > 0) {
 +        if (ssh_configure_host_alias(account) != 0) {
 +            log_warning("Failed to configure SSH host alias: %s", account->ssh_host_alias);
 +            /* Don't fail completely for host alias issues */
 +        }
 +    }
++
 +    log_info("SSH configuration switched successfully for account: %s", account->name);
 +    return 0;
 +}
++
 +/* Start isolated SSH agent */
 +int ssh_start_isolated_agent(ssh_config_t *ssh_config, const account_t *account) {
 +    char command[512];
 +    char output[1024];
 +    char socket_dir[MAX_PATH_LEN];
++
 +    if (!ssh_config || !account) {
 +        set_error(ERR_INVALID_ARGS, "Invalid arguments to ssh_start_isolated_agent");
 +        return -1;
 +    }
++
 +    log_info("Starting isolated SSH agent for account: %s", account->name);
++
 +    /* Stop any existing agent we own */
 +    if (ssh_config->agent_owned && ssh_config->agent_pid > 0) {
 +        log_debug("Stopping existing SSH agent");
 +        ssh_stop_agent(ssh_config);
 +    }
++
 +    /* Create secure socket directory */
 +    if (create_isolated_agent_socket_dir(socket_dir, sizeof(socket_dir)) != 0) {
 +        return -1;
 +    }
++
 +    /* Build ssh-agent command with socket path */
 +    if (snprintf(command, sizeof(command),
 +                 "ssh-agent -a '%s/ssh-agent.%s.sock'",
 +                 socket_dir, account->name) >= sizeof(command)) {
 +        set_error(ERR_INVALID_ARGS, "SSH agent command too long");
 +        return -1;
 +    }
++
 +    log_debug("Starting SSH agent: %s", command);
++
 +    /* Execute ssh-agent */
 +    if (execute_ssh_command(command, output, sizeof(output)) != 0) {
 +        set_error(ERR_SSH_AGENT_START_FAILED, "Failed to start SSH agent");
 +        return -1;
 +    }
++
 +    /* Parse ssh-agent output to get socket and PID */
 +    if (parse_ssh_agent_output(output, ssh_config) != 0) {
 +        set_error(ERR_SSH_AGENT_START_FAILED, "Failed to parse ssh-agent output");
 +        return -1;
 +    }
++
 +    /* Validate the agent is working */
 +    if (validate_ssh_agent_socket(ssh_config->agent_socket_path) != 0) {
 +        set_error(ERR_SSH_AGENT_START_FAILED, "SSH agent socket validation failed");
 +        return -1;
 +    }
++
 +    /* Mark as owned */
 +    ssh_config->agent_owned = true;
++
 +    /* Set up environment */
 +    if (setup_ssh_environment(ssh_config) != 0) {
 +        set_error(ERR_SSH_AGENT_START_FAILED, "Failed to set up SSH environment");
 +        return -1;
 +    }
++
 +    log_info("Isolated SSH agent started successfully (PID: %d, Socket: %s)",
 +             ssh_config->agent_pid, ssh_config->agent_socket_path);
 +    return 0;
 +}
++
 +/* Stop SSH agent */
 +int ssh_stop_agent(ssh_config_t *ssh_config) {
 +    if (!ssh_config || ssh_config->agent_pid <= 0) {
 +        return 0; /* Nothing to stop */
 +    }
++
 +    if (!ssh_config->agent_owned) {
 +        log_debug("Not stopping SSH agent - we don't own it");
 +        return 0;
 +    }
++
 +    log_info("Stopping SSH agent (PID: %d)", ssh_config->agent_pid);
++
 +    /* Try graceful shutdown first */
 +    if (kill_ssh_agent_gracefully(ssh_config->agent_pid) == 0) {
 +        log_debug("SSH agent stopped gracefully");
 +    } else {
 +        log_warning("Failed to stop SSH agent gracefully");
 +    }
++
 +    /* Clean up socket file */
 +    if (strlen(ssh_config->agent_socket_path) > 0) {
 +        if (unlink(ssh_config->agent_socket_path) == 0) {
 +            log_debug("Removed SSH agent socket: %s", ssh_config->agent_socket_path);
 +        } else {
 +            log_debug("Could not remove SSH agent socket (may already be gone)");
 +        }
 +    }
++
 +    /* Reset state */
 +    ssh_config->agent_pid = -1;
 +    ssh_config->agent_owned = false;
 +    ssh_config->agent_socket_path[0] = '\0';
++
 +    /* Clear environment */
 +    unsetenv("SSH_AUTH_SOCK");
 +    unsetenv("SSH_AGENT_PID");
++
 +    return 0;
 +}
++
 +/* Clear all keys from SSH agent */
 +int ssh_clear_agent_keys(ssh_config_t *ssh_config) {
 +    char output[512];
++
 +    if (!ssh_config || strlen(ssh_config->agent_socket_path) == 0) {
 +        log_debug("No SSH agent available to clear keys");
 +        return 0;
 +    }
++
 +    log_debug("Clearing all keys from SSH agent");
++
 +    /* Set up environment for ssh-add */
 +    if (setup_ssh_environment(ssh_config) != 0) {
 +        return -1;
 +    }
++
 +    /* Execute ssh-add -D to delete all keys */
 +    if (execute_ssh_command("ssh-add -D", output, sizeof(output)) != 0) {
 +        log_warning("Failed to clear SSH agent keys (agent may be empty)");
 +        /* This is not necessarily an error - agent might be empty */
 +    } else {
 +        log_debug("SSH agent keys cleared successfully");
 +    }
++
 +    return 0;
 +}
++
 +/* Add key to SSH agent */
 +int ssh_add_key(ssh_config_t *ssh_config, const char *key_path) {
 +    char command[MAX_PATH_LEN + 32];
 +    char output[512];
++
 +    if (!ssh_config || !key_path) {
 +        set_error(ERR_INVALID_ARGS, "Invalid arguments to ssh_add_key");
 +        return -1;
 +    }
++
 +    if (strlen(ssh_config->agent_socket_path) == 0) {
 +        set_error(ERR_SSH_AGENT_NOT_FOUND, "No SSH agent available");
 +        return -1;
 +    }
++
 +    log_debug("Adding SSH key to agent: %s", key_path);
++
 +    /* Set up environment */
 +    if (setup_ssh_environment(ssh_config) != 0) {
 +        return -1;
 +    }
++
 +    /* Build ssh-add command */
 +    if (snprintf(command, sizeof(command), "ssh-add '%s'", key_path) >= sizeof(command)) {
 +        set_error(ERR_INVALID_ARGS, "SSH add command too long");
 +        return -1;
 +    }
++
 +    /* Execute ssh-add */
 +    if (execute_ssh_command(command, output, sizeof(output)) != 0) {
 +        set_error(ERR_SSH_KEY_LOAD_FAILED, "Failed to add SSH key: %s", output);
 +        return -1;
 +    }
++
 +    log_info("SSH key added successfully: %s", key_path);
 +    return 0;
 +}
++
 +/* List loaded SSH keys */
 +int ssh_list_keys(ssh_config_t *ssh_config, char *output, size_t output_size) {
 +    if (!ssh_config || !output || output_size == 0) {
 +        set_error(ERR_INVALID_ARGS, "Invalid arguments to ssh_list_keys");
 +        return -1;
 +    }
++
 +    if (strlen(ssh_config->agent_socket_path) == 0) {
 +        safe_strncpy(output, "No SSH agent available", output_size);
 +        return -1;
 +    }
++
 +    /* Set up environment */
 +    if (setup_ssh_environment(ssh_config) != 0) {
 +        return -1;
 +    }
++
 +    /* Execute ssh-add -l */
 +    if (execute_ssh_command("ssh-add -l", output, output_size) != 0) {
 +        safe_strncpy(output, "No keys loaded in SSH agent", output_size);
 +        return -1;
 +    }
++
 +    return 0;
 +}
++
 +/* Validate SSH key file */
 +int ssh_validate_key_file(const char *key_path) {
 +    struct stat key_stat;
 +    mode_t key_mode;
++
 +    if (!key_path) {
 +        set_error(ERR_INVALID_ARGS, "NULL key_path to ssh_validate_key_file");
 +        return -1;
 +    }
++
 +    /* Check if file exists */
 +    if (stat(key_path, &key_stat) != 0) {
 +        set_system_error(ERR_SSH_KEY_NOT_FOUND, "SSH key file not found: %s", key_path);
 +        return -1;
 +    }
++
 +    /* Check if it's a regular file */
 +    if (!S_ISREG(key_stat.st_mode)) {
 +        set_error(ERR_SSH_KEY_INVALID, "SSH key path is not a regular file: %s", key_path);
 +        return -1;
 +    }
++
 +    /* Check permissions - should be 600 (readable only by owner) */
 +    key_mode = key_stat.st_mode & 0777;
 +    if (key_mode != 0600) {
 +        set_error(ERR_SSH_KEY_PERMISSIONS,
 +                  "SSH key file has unsafe permissions: %o (should be 600): %s",
 +                  key_mode, key_path);
 +        return -1;
 +    }
++
 +    /* Check ownership - should be owned by current user */
 +    if (key_stat.st_uid != getuid()) {
 +        set_error(ERR_SSH_KEY_OWNERSHIP, "SSH key file not owned by current user: %s", key_path);
 +        return -1;
 +    }
++
 +    /* Basic content validation - check it looks like a private key */
 +    FILE *key_file = fopen(key_path, "r");
 +    if (!key_file) {
 +        set_system_error(ERR_SSH_KEY_INVALID, "Cannot read SSH key file: %s", key_path);
 +        return -1;
 +    }
++
 +    char first_line[256];
 +    bool valid_key = false;
++
 +    if (fgets(first_line, sizeof(first_line), key_file)) {
 +        /* Check for common private key headers */
 +        if (strstr(first_line, "-----BEGIN") &&
 +            (strstr(first_line, "PRIVATE KEY") ||
 +             strstr(first_line, "RSA PRIVATE KEY") ||
 +             strstr(first_line, "OPENSSH PRIVATE KEY") ||
 +             strstr(first_line, "EC PRIVATE KEY"))) {
 +            valid_key = true;
 +        }
 +    }
++
 +    fclose(key_file);
++
 +    if (!valid_key) {
 +        set_error(ERR_SSH_KEY_INVALID, "File does not appear to be a valid SSH private key: %s", key_path);
 +        return -1;
 +    }
++
 +    log_debug("SSH key validation passed: %s", key_path);
 +    return 0;
 +}
++
 +/* Configure SSH host alias */
 +int ssh_configure_host_alias(const account_t *account) {
 +    char ssh_config_path[MAX_PATH_LEN];
 +    char ssh_config_dir[MAX_PATH_LEN];
 +    FILE *ssh_config_file;
 +    char expanded_key_path[MAX_PATH_LEN];
++
 +    if (!account || strlen(account->ssh_host_alias) == 0) {
 +        return 0; /* Nothing to configure */
 +    }
++
 +    log_debug("Configuring SSH host alias: %s", account->ssh_host_alias);
++
 +    /* Get SSH config directory */
 +    if (snprintf(ssh_config_dir, sizeof(ssh_config_dir), "%s/.ssh", getenv("HOME")) >= sizeof(ssh_config_dir)) {
 +        set_error(ERR_INVALID_PATH, "SSH config directory path too long");
 +        return -1;
 +    }
++
 +    /* Create .ssh directory if it doesn't exist */
 +    if (!path_exists(ssh_config_dir)) {
 +        if (create_directory_recursive(ssh_config_dir, 0700) != 0) {
 +            return -1;
 +        }
 +    }
++
 +    /* SSH config file path */
 +    if (snprintf(ssh_config_path, sizeof(ssh_config_path), "%s/config", ssh_config_dir) >= sizeof(ssh_config_path)) {
 +        set_error(ERR_INVALID_PATH, "SSH config file path too long");
 +        return -1;
 +    }
++
 +    /* Expand key path */
 +    if (expand_path(account->ssh_key_path, expanded_key_path, sizeof(expanded_key_path)) != 0) {
 +        return -1;
 +    }
++
 +    /* Append to SSH config file */
 +    ssh_config_file = fopen(ssh_config_path, "a");
 +    if (!ssh_config_file) {
 +        set_system_error(ERR_FILE_IO, "Failed to open SSH config file: %s", ssh_config_path);
 +        return -1;
 +    }
++
 +    /* Write host configuration */
 +    fprintf(ssh_config_file, "\n# gitswitch-c configuration for account: %s\n", account->name);
 +    fprintf(ssh_config_file, "Host %s\n", account->ssh_host_alias);
 +    fprintf(ssh_config_file, "  IdentityFile %s\n", expanded_key_path);
 +    fprintf(ssh_config_file, "  IdentitiesOnly yes\n");
 +    fprintf(ssh_config_file, "  StrictHostKeyChecking no\n");
 +    fprintf(ssh_config_file, "  UserKnownHostsFile /dev/null\n");
++
 +    fclose(ssh_config_file);
++
 +    /* Set proper permissions on SSH config file */
 +    if (chmod(ssh_config_path, 0600) != 0) {
 +        log_warning("Failed to set permissions on SSH config file");
 +    }
++
 +    log_info("SSH host alias configured: %s -> %s", account->ssh_host_alias, expanded_key_path);
 +    return 0;
 +}
++
 +/* Test SSH connection */
 +int ssh_test_connection(const account_t *account, const char *host) {
 +    char command[512];
 +    char output[1024];
++
 +    if (!account || !host) {
 +        set_error(ERR_INVALID_ARGS, "Invalid arguments to ssh_test_connection");
 +        return -1;
 +    }
++
 +    log_debug("Testing SSH connection to: %s", host);
++
 +    /* Build SSH test command */
 +    if (strlen(account->ssh_host_alias) > 0) {
 +        /* Use host alias */
 +        if (snprintf(command, sizeof(command),
 +                     "ssh -o ConnectTimeout=5 -o BatchMode=yes %s echo 'SSH connection test successful'",
 +                     account->ssh_host_alias) >= sizeof(command)) {
 +            set_error(ERR_INVALID_ARGS, "SSH test command too long");
 +            return -1;
 +        }
 +    } else {
 +        /* Use direct host with identity file */
 +        char expanded_key_path[MAX_PATH_LEN];
 +        if (expand_path(account->ssh_key_path, expanded_key_path, sizeof(expanded_key_path)) != 0) {
 +            return -1;
 +        }
++
 +        if (snprintf(command, sizeof(command),
 +                     "ssh -o ConnectTimeout=5 -o BatchMode=yes -i '%s' %s echo 'SSH connection test successful'",
 +                     expanded_key_path, host) >= sizeof(command)) {
 +            set_error(ERR_INVALID_ARGS, "SSH test command too long");
 +            return -1;
 +        }
 +    }
++
 +    /* Execute SSH test */
 +    if (execute_ssh_command(command, output, sizeof(output)) != 0) {
 +        set_error(ERR_SSH_CONNECTION_FAILED, "SSH connection test failed to %s: %s", host, output);
 +        return -1;
 +    }
++
 +    if (!strstr(output, "SSH connection test successful")) {
 +        set_error(ERR_SSH_CONNECTION_FAILED, "SSH connection test did not return expected output");
 +        return -1;
 +    }
++
 +    log_info("SSH connection test successful to: %s", host);
 +    return 0;
 +}
++
 +/* Internal helper functions */
++
 +/* Execute SSH command */
 +static int execute_ssh_command(const char *command, char *output, size_t output_size) {
 +    FILE *pipe;
++
 +    if (!command) {
 +        return -1;
 +    }
++
 +    log_debug("Executing SSH command: %s", command);
++
 +    pipe = popen(command, "r");
 +    if (!pipe) {
 +        set_system_error(ERR_SYSTEM_COMMAND_FAILED, "Failed to execute SSH command");
 +        return -1;
 +    }
++
 +    /* Read output if buffer provided */
 +    if (output && output_size > 0) {
 +        size_t total_read = 0;
 +        char *pos = output;
++
 +        while (total_read < output_size - 1 &&
 +               fgets(pos, output_size - total_read, pipe)) {
 +            size_t line_len = strlen(pos);
 +            total_read += line_len;
 +            pos += line_len;
 +        }
 +        output[total_read] = '\0';
++
 +        /* Remove trailing newline */
 +        if (total_read > 0 && output[total_read - 1] == '\n') {
 +            output[total_read - 1] = '\0';
 +        }
 +    }
++
 +    int exit_code = pclose(pipe);
 +    if (exit_code != 0) {
 +        log_debug("SSH command failed with exit code: %d", exit_code);
 +        return -1;
 +    }
++
 +    return 0;
 +}
++
 +/* Set up SSH environment variables */
 +static int setup_ssh_environment(ssh_config_t *ssh_config) {
 +    if (!ssh_config || strlen(ssh_config->agent_socket_path) == 0) {
 +        return -1;
 +    }
++
 +    /* Set SSH_AUTH_SOCK */
 +    if (setenv("SSH_AUTH_SOCK", ssh_config->agent_socket_path, 1) != 0) {
 +        set_system_error(ERR_SYSTEM_CALL, "Failed to set SSH_AUTH_SOCK");
 +        return -1;
 +    }
++
 +    /* Set SSH_AGENT_PID if we have it */
 +    if (ssh_config->agent_pid > 0) {
 +        char pid_str[32];
 +        snprintf(pid_str, sizeof(pid_str), "%d", ssh_config->agent_pid);
 +        if (setenv("SSH_AGENT_PID", pid_str, 1) != 0) {
 +            set_system_error(ERR_SYSTEM_CALL, "Failed to set SSH_AGENT_PID");
 +            return -1;
 +        }
 +    }
++
 +    log_debug("SSH environment configured: SSH_AUTH_SOCK=%s, SSH_AGENT_PID=%d",
 +              ssh_config->agent_socket_path, ssh_config->agent_pid);
 +    return 0;
 +}
++
 +/* Create isolated agent socket directory */
 +static int create_isolated_agent_socket_dir(char *socket_dir, size_t socket_dir_size) {
 +    const char *runtime_dir = getenv("XDG_RUNTIME_DIR");
 +    const char *tmp_dir = "/tmp";
++
 +    /* Prefer XDG_RUNTIME_DIR if available */
 +    if (runtime_dir && path_exists(runtime_dir)) {
 +        if (snprintf(socket_dir, socket_dir_size, "%s/gitswitch-ssh", runtime_dir) >= socket_dir_size) {
 +            set_error(ERR_INVALID_PATH, "Socket directory path too long");
 +            return -1;
 +        }
 +    } else {
 +        if (snprintf(socket_dir, socket_dir_size, "%s/gitswitch-ssh-%d", tmp_dir, getuid()) >= socket_dir_size) {
 +            set_error(ERR_INVALID_PATH, "Socket directory path too long");
 +            return -1;
 +        }
 +    }
++
 +    /* Create directory with secure permissions */
 +    if (!path_exists(socket_dir)) {
 +        if (create_directory_recursive(socket_dir, 0700) != 0) {
 +            return -1;
 +        }
 +        log_debug("Created SSH socket directory: %s", socket_dir);
 +    }
++
 +    /* Verify permissions */
 +    struct stat dir_stat;
 +    if (stat(socket_dir, &dir_stat) != 0) {
 +        set_system_error(ERR_FILE_IO, "Failed to stat socket directory");
 +        return -1;
 +    }
++
 +    if ((dir_stat.st_mode & 0777) != 0700) {
 +        set_error(ERR_PERMISSION_DENIED, "Socket directory has insecure permissions");
 +        return -1;
 +    }
++
 +    return 0;
 +}
++
 +/* Check if SSH agent is running */
 +static bool is_ssh_agent_running(pid_t pid) {
 +    if (pid <= 0) {
 +        return false;
 +    }
++
 +    /* Use kill(pid, 0) to test if process exists */
 +    return (kill(pid, 0) == 0);
 +}
++
 +/* Kill SSH agent gracefully */
 +static int kill_ssh_agent_gracefully(pid_t pid) {
 +    if (pid <= 0) {
 +        return -1;
 +    }
++
 +    if (!is_ssh_agent_running(pid)) {
 +        log_debug("SSH agent (PID: %d) not running", pid);
 +        return 0;
 +    }
++
 +    /* Send SIGTERM first */
 +    if (kill(pid, SIGTERM) != 0) {
 +        set_system_error(ERR_SYSTEM_CALL, "Failed to send SIGTERM to SSH agent");
 +        return -1;
 +    }
++
 +    /* Wait a bit for graceful shutdown */
 +    for (int i = 0; i < 10; i++) {
 +        if (!is_ssh_agent_running(pid)) {
 +            return 0;
 +        }
 +        usleep(100000); /* 100ms */
 +    }
++
 +    /* Force kill if still running */
 +    if (is_ssh_agent_running(pid)) {
 +        log_warning("SSH agent did not respond to SIGTERM, sending SIGKILL");
 +        if (kill(pid, SIGKILL) != 0) {
 +            set_system_error(ERR_SYSTEM_CALL, "Failed to send SIGKILL to SSH agent");
 +            return -1;
 +        }
 +    }
++
 +    return 0;
 +}
++
 +/* Validate SSH agent socket */
 +static int validate_ssh_agent_socket(const char *socket_path) {
 +    struct stat socket_stat;
++
 +    if (!socket_path) {
 +        return -1;
 +    }
++
 +    /* Check if socket exists */
 +    if (stat(socket_path, &socket_stat) != 0) {
 +        set_system_error(ERR_SSH_AGENT_SOCKET_INVALID, "SSH agent socket not found: %s", socket_path);
 +        return -1;
 +    }
++
 +    /* Check if it's a socket */
 +    if (!S_ISSOCK(socket_stat.st_mode)) {
 +        set_error(ERR_SSH_AGENT_SOCKET_INVALID, "Path is not a socket: %s", socket_path);
 +        return -1;
 +    }
++
 +    /* Check permissions */
 +    if ((socket_stat.st_mode & 0777) != 0600) {
 +        set_error(ERR_SSH_AGENT_SOCKET_INVALID, "SSH agent socket has wrong permissions: %s", socket_path);
 +        return -1;
 +    }
++
 +    return 0;
 +}
++
 +/* Parse ssh-agent output */
 +static int parse_ssh_agent_output(const char *output, ssh_config_t *ssh_config) {
 +    char *line;
 +    char *output_copy;
 +    char *saveptr;
++
 +    if (!output || !ssh_config) {
 +        return -1;
 +    }
++
 +    /* Make a copy of output for parsing */
 +    output_copy = strdup(output);
 +    if (!output_copy) {
 +        set_error(ERR_MEMORY_ALLOCATION, "Failed to allocate memory for parsing");
 +        return -1;
 +    }
++
 +    /* Parse line by line */
 +    line = strtok_r(output_copy, "\n", &saveptr);
 +    while (line) {
 +        /* Look for SSH_AUTH_SOCK */
 +        if (strstr(line, "SSH_AUTH_SOCK=")) {
 +            char *socket_start = strchr(line, '=') + 1;
 +            char *socket_end = strchr(socket_start, ';');
 +            if (socket_end) {
 +                *socket_end = '\0';
 +            }
 +            safe_strncpy(ssh_config->agent_socket_path, socket_start,
 +                        sizeof(ssh_config->agent_socket_path));
 +        }
++
 +        /* Look for SSH_AGENT_PID */
 +        if (strstr(line, "SSH_AGENT_PID=")) {
 +            char *pid_start = strchr(line, '=') + 1;
 +            char *pid_end = strchr(pid_start, ';');
 +            if (pid_end) {
 +                *pid_end = '\0';
 +            }
 +            ssh_config->agent_pid = (pid_t)strtol(pid_start, NULL, 10);
 +        }
++
 +        line = strtok_r(NULL, "\n", &saveptr);
 +    }
++
 +    free(output_copy);
++
 +    /* Validate we got the required information */
 +    if (strlen(ssh_config->agent_socket_path) == 0 || ssh_config->agent_pid <= 0) {
 +        set_error(ERR_SSH_AGENT_START_FAILED, "Failed to parse ssh-agent output");
 +        return -1;
 +    }
++
 +    return 0;
 +}

src/stubs.cadded

 +/* Temporary stub implementations for Phase 1 compilation
 + * These will be replaced with actual implementations in later phases
 + */
++
 +#include <stdio.h>
 +#include <string.h>
 +#include "gitswitch.h"
 +#include "display.h"
 +#include "error.h"
++
 +/* SSH manager stubs */
 +int ssh_list_keys(ssh_config_t *ssh_config, char *output, size_t output_size) {
 +    (void)ssh_config;
 +    if (output && output_size > 0) {
 +        strncpy(output, "SSH functionality not yet implemented", output_size - 1);
 +        output[output_size - 1] = '\0';
 +    }
 +    return -1; /* Not implemented */
 +}
++
 +/* GPG manager stubs */
 +int gpg_list_keys(gpg_config_t *gpg_config, char *output, size_t output_size) {
 +    (void)gpg_config;
 +    if (output && output_size > 0) {
 +        strncpy(output, "GPG functionality not yet implemented", output_size - 1);
 +        output[output_size - 1] = '\0';
 +    }
 +    return -1; /* Not implemented */
 +}

src/toml_parser.cadded

1064 lines changed — click to load

 +/* Minimal, security-focused TOML parser implementation
 + * Built specifically for gitswitch-c with comprehensive input validation
 + */
++
 +#include <stdio.h>
 +#include <stdlib.h>
 +#include <string.h>
 +#include <ctype.h>
 +#include <errno.h>
 +#include <limits.h>
 +#include <sys/stat.h>
++
 +#include "toml_parser.h"
 +#include "error.h"
 +#include "utils.h"
++
 +/* Internal parsing helper functions */
 +static int parse_section_header(toml_parser_state_t *state, char *section_name);
 +static int parse_key_value_pair(toml_parser_state_t *state, toml_keyvalue_t *kv);
 +static int parse_string_value(toml_parser_state_t *state, char *value, size_t value_size);
 +static int parse_integer_value(toml_parser_state_t *state, int *value);
 +static int parse_boolean_value(toml_parser_state_t *state, bool *value);
 +static void skip_whitespace(toml_parser_state_t *state);
 +static void skip_comment(toml_parser_state_t *state);
 +static bool is_at_end(const toml_parser_state_t *state);
 +static char current_char(const toml_parser_state_t *state);
 +static char advance_char(toml_parser_state_t *state);
 +static bool match_char(toml_parser_state_t *state, char expected);
 +static void set_parser_error(toml_parser_state_t *state, const char *message);
 +static toml_section_t *find_section(toml_document_t *doc, const char *section_name);
 +static toml_section_t *find_or_create_section(toml_document_t *doc, const char *section_name);
 +static toml_keyvalue_t *find_key(toml_section_t *section, const char *key_name);
++
 +/* Initialize TOML document structure */
 +void toml_init_document(toml_document_t *doc) {
 +    if (!doc) return;
++
 +    memset(doc, 0, sizeof(toml_document_t));
 +    doc->is_valid = false;
 +    doc->section_count = 0;
 +}
++
 +/* Parse TOML from file with comprehensive security validation */
 +int toml_parse_file(const char *file_path, toml_document_t *doc) {
 +    FILE *file;
 +    struct stat file_stat;
 +    char *buffer = NULL;
 +    size_t file_size;
 +    size_t bytes_read;
 +    int result = -1;
++
 +    if (!file_path || !doc) {
 +        set_error(ERR_INVALID_ARGS, "NULL arguments to toml_parse_file");
 +        return -1;
 +    }
++
 +    /* Security: Validate file path */
 +    if (!toml_validate_file_path(file_path)) {
 +        set_error(ERR_CONFIG_INVALID, "Invalid file path: %s", file_path);
 +        return -1;
 +    }
++
 +    /* Get file statistics for security checks */
 +    if (stat(file_path, &file_stat) != 0) {
 +        set_system_error(ERR_CONFIG_NOT_FOUND, "Cannot access config file: %s", file_path);
 +        return -1;
 +    }
++
 +    /* Security: Check file size limit */
 +    if (file_stat.st_size > TOML_MAX_FILE_SIZE) {
 +        set_error(ERR_CONFIG_INVALID, "Configuration file too large: %ld bytes (max: %d)",
 +                  file_stat.st_size, TOML_MAX_FILE_SIZE);
 +        return -1;
 +    }
++
 +    /* Security: Check file permissions (should not be world-readable) */
 +    if (file_stat.st_mode & (S_IRGRP | S_IROTH)) {
 +        set_error(ERR_PERMISSION_DENIED, "Configuration file has unsafe permissions: %o",
 +                  file_stat.st_mode & 0777);
 +        return -1;
 +    }
++
 +    file_size = (size_t)file_stat.st_size;
++
 +    /* Open file for reading */
 +    file = fopen(file_path, "r");
 +    if (!file) {
 +        set_system_error(ERR_CONFIG_NOT_FOUND, "Failed to open config file: %s", file_path);
 +        return -1;
 +    }
++
 +    /* Allocate buffer for file content */
 +    buffer = safe_malloc(file_size + 1);
 +    if (!buffer) {
 +        fclose(file);
 +        return -1;
 +    }
++
 +    /* Read file content */
 +    bytes_read = fread(buffer, 1, file_size, file);
 +    if (bytes_read != file_size) {
 +        set_system_error(ERR_FILE_IO, "Failed to read complete config file: %s", file_path);
 +        goto cleanup;
 +    }
++
 +    buffer[file_size] = '\0';
 +    fclose(file);
 +    file = NULL;
++
 +    /* Security: Validate character set */
 +    if (!toml_validate_safe_characters(buffer, file_size)) {
 +        set_error(ERR_CONFIG_INVALID, "Configuration file contains unsafe characters");
 +        goto cleanup;
 +    }
++
 +    /* Security: Check for injection patterns */
 +    if (!toml_check_injection_patterns(buffer, file_size)) {
 +        set_error(ERR_CONFIG_INVALID, "Configuration file contains potentially malicious patterns");
 +        goto cleanup;
 +    }
++
 +    /* Store file path in document */
 +    safe_strncpy(doc->file_path, file_path, sizeof(doc->file_path));
++
 +    /* Parse the TOML content */
 +    result = toml_parse_string(buffer, file_size, doc);
++
 +cleanup:
 +    if (file) fclose(file);
 +    if (buffer) {
 +        secure_zero_memory(buffer, file_size + 1);
 +        free(buffer);
 +    }
++
 +    return result;
 +}
++
 +/* Parse TOML from string buffer */
 +int toml_parse_string(const char *toml_string, size_t length, toml_document_t *doc) {
 +    toml_parser_state_t state;
 +    char section_name[TOML_MAX_SECTION_LEN] = ""; /* Default to root section */
 +    toml_section_t *current_section = NULL;
++
 +    if (!toml_string || !doc || length == 0) {
 +        set_error(ERR_INVALID_ARGS, "Invalid arguments to toml_parse_string");
 +        return -1;
 +    }
++
 +    /* Initialize parser state */
 +    memset(&state, 0, sizeof(state));
 +    state.input = toml_string;
 +    state.input_length = length;
 +    state.position = 0;
 +    state.line_number = 1;
 +    state.column_number = 1;
 +    state.has_error = false;
++
 +    /* Initialize document */
 +    toml_init_document(doc);
++
 +    /* Parse line by line */
 +    while (!is_at_end(&state) && !state.has_error) {
 +        skip_whitespace(&state);
++
 +        if (is_at_end(&state)) {
 +            break;
 +        }
++
 +        char c = current_char(&state);
++
 +        /* Skip comments */
 +        if (c == '#') {
 +            skip_comment(&state);
 +            continue;
 +        }
++
 +        /* Parse section header */
 +        if (c == '[') {
 +            if (parse_section_header(&state, section_name) == 0) {
 +                current_section = find_or_create_section(doc, section_name);
 +                if (!current_section) {
 +                    set_parser_error(&state, "Failed to create section");
 +                    break;
 +                }
 +            }
 +            continue;
 +        }
++
 +        /* Parse key-value pair */
 +        if (isalpha(c) || c == '_') {
 +            if (!current_section) {
 +                /* Create default section if none exists */
 +                current_section = find_or_create_section(doc, "");
 +                if (!current_section) {
 +                    set_parser_error(&state, "Failed to create default section");
 +                    break;
 +                }
 +            }
++
 +            if (current_section->key_count >= TOML_MAX_KEYS_PER_SECTION) {
 +                set_parser_error(&state, "Too many keys in section");
 +                break;
 +            }
++
 +            toml_keyvalue_t *kv = &current_section->keys[current_section->key_count];
 +            if (parse_key_value_pair(&state, kv) == 0) {
 +                current_section->key_count++;
 +            }
 +            continue;
 +        }
++
 +        /* Skip empty lines */
 +        if (c == '\n' || c == '\r') {
 +            advance_char(&state);
 +            continue;
 +        }
++
 +        /* Unknown character */
 +        set_parser_error(&state, "Unexpected character");
 +        break;
 +    }
++
 +    if (state.has_error) {
 +        set_error(ERR_CONFIG_INVALID, "TOML parsing failed at line %zu, column %zu: %s",
 +                  state.line_number, state.column_number, state.error_message);
 +        return -1;
 +    }
++
 +    /* Validate the parsed document against our schema */
 +    if (toml_validate_gitswitch_schema(doc) != 0) {
 +        return -1;
 +    }
++
 +    doc->is_valid = true;
 +    log_debug("TOML document parsed successfully: %zu sections", doc->section_count);
++
 +    return 0;
 +}
++
 +/* Get string value from TOML document */
 +int toml_get_string(const toml_document_t *doc, const char *section,
 +                    const char *key, char *value, size_t value_size) {
 +    const toml_section_t *sec;
 +    const toml_keyvalue_t *kv;
++
 +    if (!doc || !section || !key || !value || value_size == 0) {
 +        set_error(ERR_INVALID_ARGS, "Invalid arguments to toml_get_string");
 +        return -1;
 +    }
++
 +    if (!doc->is_valid) {
 +        set_error(ERR_CONFIG_INVALID, "TOML document is not valid");
 +        return -1;
 +    }
++
 +    sec = find_section((toml_document_t *)doc, section);
 +    if (!sec) {
 +        set_error(ERR_CONFIG_INVALID, "Section not found: %s", section);
 +        return -1;
 +    }
++
 +    kv = find_key((toml_section_t *)sec, key);
 +    if (!kv || !kv->is_set) {
 +        set_error(ERR_CONFIG_INVALID, "Key not found: %s.%s", section, key);
 +        return -1;
 +    }
++
 +    if (kv->type != TOML_TYPE_STRING) {
 +        set_error(ERR_CONFIG_INVALID, "Key %s.%s is not a string", section, key);
 +        return -1;
 +    }
++
 +    /* Sanitize the value before returning */
 +    return toml_sanitize_string(kv->value, value, value_size);
 +}
++
 +/* Get integer value from TOML document */
 +int toml_get_integer(const toml_document_t *doc, const char *section,
 +                     const char *key, int *value) {
 +    const toml_section_t *sec;
 +    const toml_keyvalue_t *kv;
 +    char *endptr;
 +    long parsed_value;
++
 +    if (!doc || !section || !key || !value) {
 +        set_error(ERR_INVALID_ARGS, "Invalid arguments to toml_get_integer");
 +        return -1;
 +    }
++
 +    if (!doc->is_valid) {
 +        set_error(ERR_CONFIG_INVALID, "TOML document is not valid");
 +        return -1;
 +    }
++
 +    sec = find_section((toml_document_t *)doc, section);
 +    if (!sec) {
 +        set_error(ERR_CONFIG_INVALID, "Section not found: %s", section);
 +        return -1;
 +    }
++
 +    kv = find_key((toml_section_t *)sec, key);
 +    if (!kv || !kv->is_set) {
 +        set_error(ERR_CONFIG_INVALID, "Key not found: %s.%s", section, key);
 +        return -1;
 +    }
++
 +    if (kv->type != TOML_TYPE_INTEGER) {
 +        set_error(ERR_CONFIG_INVALID, "Key %s.%s is not an integer", section, key);
 +        return -1;
 +    }
++
 +    errno = 0;
 +    parsed_value = strtol(kv->value, &endptr, 10);
++
 +    if (errno != 0 || *endptr != '\0') {
 +        set_error(ERR_CONFIG_INVALID, "Invalid integer value: %s", kv->value);
 +        return -1;
 +    }
++
 +    if (parsed_value < INT_MIN || parsed_value > INT_MAX) {
 +        set_error(ERR_CONFIG_INVALID, "Integer value out of range: %ld", parsed_value);
 +        return -1;
 +    }
++
 +    *value = (int)parsed_value;
 +    return 0;
 +}
++
 +/* Get boolean value from TOML document */
 +int toml_get_boolean(const toml_document_t *doc, const char *section,
 +                     const char *key, bool *value) {
 +    const toml_section_t *sec;
 +    const toml_keyvalue_t *kv;
++
 +    if (!doc || !section || !key || !value) {
 +        set_error(ERR_INVALID_ARGS, "Invalid arguments to toml_get_boolean");
 +        return -1;
 +    }
++
 +    if (!doc->is_valid) {
 +        set_error(ERR_CONFIG_INVALID, "TOML document is not valid");
 +        return -1;
 +    }
++
 +    sec = find_section((toml_document_t *)doc, section);
 +    if (!sec) {
 +        set_error(ERR_CONFIG_INVALID, "Section not found: %s", section);
 +        return -1;
 +    }
++
 +    kv = find_key((toml_section_t *)sec, key);
 +    if (!kv || !kv->is_set) {
 +        set_error(ERR_CONFIG_INVALID, "Key not found: %s.%s", section, key);
 +        return -1;
 +    }
++
 +    if (kv->type != TOML_TYPE_BOOLEAN) {
 +        set_error(ERR_CONFIG_INVALID, "Key %s.%s is not a boolean", section, key);
 +        return -1;
 +    }
++
 +    *value = (strcmp(kv->value, "true") == 0);
 +    return 0;
 +}
++
 +/* Validate TOML document structure for gitswitch schema */
 +int toml_validate_gitswitch_schema(const toml_document_t *doc) {
 +    if (!doc) {
 +        set_error(ERR_INVALID_ARGS, "NULL document to validate");
 +        return -1;
 +    }
++
 +    /* Check for required sections */
 +    bool has_settings = false;
 +    bool has_accounts = false;
++
 +    for (size_t i = 0; i < doc->section_count; i++) {
 +        const toml_section_t *section = &doc->sections[i];
++
 +        if (strcmp(section->name, "settings") == 0) {
 +            has_settings = true;
++
 +            /* Validate settings section */
 +            bool has_default_scope = false;
 +            for (size_t j = 0; j < section->key_count; j++) {
 +                const toml_keyvalue_t *kv = &section->keys[j];
++
 +                if (strcmp(kv->key, "default_scope") == 0) {
 +                    has_default_scope = true;
 +                    if (kv->type != TOML_TYPE_STRING) {
 +                        set_error(ERR_CONFIG_INVALID, "default_scope must be a string");
 +                        return -1;
 +                    }
 +                    if (strcmp(kv->value, "local") != 0 && strcmp(kv->value, "global") != 0) {
 +                        set_error(ERR_CONFIG_INVALID, "default_scope must be 'local' or 'global'");
 +                        return -1;
 +                    }
 +                }
 +            }
++
 +            if (!has_default_scope) {
 +                set_error(ERR_CONFIG_INVALID, "settings section missing required default_scope");
 +                return -1;
 +            }
 +        }
++
 +        if (string_starts_with(section->name, "accounts.")) {
 +            has_accounts = true;
++
 +            /* Validate account section */
 +            bool has_name = false, has_email = false;
++
 +            for (size_t j = 0; j < section->key_count; j++) {
 +                const toml_keyvalue_t *kv = &section->keys[j];
++
 +                if (strcmp(kv->key, "name") == 0) {
 +                    has_name = true;
 +                    if (kv->type != TOML_TYPE_STRING || strlen(kv->value) == 0) {
 +                        set_error(ERR_CONFIG_INVALID, "Account name must be a non-empty string");
 +                        return -1;
 +                    }
 +                }
++
 +                if (strcmp(kv->key, "email") == 0) {
 +                    has_email = true;
 +                    if (kv->type != TOML_TYPE_STRING || !validate_email(kv->value)) {
 +                        set_error(ERR_CONFIG_INVALID, "Account email must be a valid email address");
 +                        return -1;
 +                    }
 +                }
++
 +                if (strcmp(kv->key, "ssh_key") == 0) {
 +                    if (kv->type != TOML_TYPE_STRING) {
 +                        set_error(ERR_CONFIG_INVALID, "ssh_key must be a string");
 +                        return -1;
 +                    }
 +                    if (strlen(kv->value) > 0 && !toml_validate_file_path(kv->value)) {
 +                        set_error(ERR_CONFIG_INVALID, "Invalid SSH key path: %s", kv->value);
 +                        return -1;
 +                    }
 +                }
++
 +                if (strcmp(kv->key, "gpg_key") == 0) {
 +                    if (kv->type != TOML_TYPE_STRING) {
 +                        set_error(ERR_CONFIG_INVALID, "gpg_key must be a string");
 +                        return -1;
 +                    }
 +                    if (strlen(kv->value) > 0 && !validate_key_id(kv->value)) {
 +                        set_error(ERR_CONFIG_INVALID, "Invalid GPG key ID: %s", kv->value);
 +                        return -1;
 +                    }
 +                }
 +            }
++
 +            if (!has_name || !has_email) {
 +                set_error(ERR_CONFIG_INVALID, "Account section %s missing required name or email",
 +                          section->name);
 +                return -1;
 +            }
 +        }
 +    }
++
 +    if (!has_settings) {
 +        set_error(ERR_CONFIG_INVALID, "Configuration missing required [settings] section");
 +        return -1;
 +    }
++
 +    if (!has_accounts) {
 +        log_info("Configuration has no account sections yet - this is normal for new installations");
 +        /* This is not an error - allow empty configurations */
 +    }
++
 +    log_debug("TOML document schema validation passed");
 +    return 0;
 +}
++
 +/* Security validation: Check for safe characters only */
 +bool toml_validate_safe_characters(const char *input, size_t length) {
 +    if (!input) return false;
++
 +    for (size_t i = 0; i < length; i++) {
 +        unsigned char c = (unsigned char)input[i];
++
 +        /* Allow printable ASCII, newlines, tabs, and carriage returns */
 +        if (!(c >= 32 && c <= 126) && c != '\n' && c != '\r' && c != '\t') {
 +            log_warning("Unsafe character found at position %zu: 0x%02x", i, c);
 +            return false;
 +        }
 +    }
++
 +    return true;
 +}
++
 +/* Sanitize string value */
 +int toml_sanitize_string(const char *input, char *output, size_t output_size) {
 +    size_t input_len, output_pos = 0;
++
 +    if (!input || !output || output_size == 0) {
 +        set_error(ERR_INVALID_ARGS, "Invalid arguments to toml_sanitize_string");
 +        return -1;
 +    }
++
 +    input_len = strlen(input);
++
 +    for (size_t i = 0; i < input_len && output_pos < output_size - 1; i++) {
 +        char c = input[i];
++
 +        /* Remove or escape potentially dangerous characters */
 +        if (c >= 32 && c <= 126 && c != '"' && c != '\\') {
 +            output[output_pos++] = c;
 +        }
 +        /* Allow some whitespace */
 +        else if (c == ' ' || c == '\t') {
 +            output[output_pos++] = c;
 +        }
 +        /* Skip other characters */
 +    }
++
 +    output[output_pos] = '\0';
 +    return 0;
 +}
++
 +/* Validate file path for security */
 +bool toml_validate_file_path(const char *path) {
 +    if (!path || strlen(path) == 0) return true; /* Empty path is allowed */
++
 +    /* Check for directory traversal attempts */
 +    if (strstr(path, "..") != NULL) {
 +        log_warning("Directory traversal attempt in path: %s", path);
 +        return false;
 +    }
++
 +    /* Check for absolute paths outside user home */
 +    if (path[0] == '/' && !string_starts_with(path, "/home/") &&
 +        !string_starts_with(path, "/tmp/")) {
 +        log_warning("Suspicious absolute path: %s", path);
 +        return false;
 +    }
++
 +    /* Check path length */
 +    if (strlen(path) > 256) {
 +        log_warning("Path too long: %zu characters", strlen(path));
 +        return false;
 +    }
++
 +    return true;
 +}
++
 +/* Check for TOML injection patterns */
 +bool toml_check_injection_patterns(const char *input, size_t length) {
 +    const char *dangerous_patterns[] = {
 +        "$(", "`", "${", "\\x", "\\u", NULL
 +    };
++
 +    if (!input) return false;
++
 +    for (int i = 0; dangerous_patterns[i] != NULL; i++) {
 +        if (strstr(input, dangerous_patterns[i]) != NULL) {
 +            log_warning("Potentially dangerous pattern found: %s", dangerous_patterns[i]);
 +            return false;
 +        }
 +    }
++
 +    /* Check for excessive nesting or repetition */
 +    size_t bracket_count = 0;
 +    for (size_t i = 0; i < length; i++) {
 +        if (input[i] == '[') {
 +            bracket_count++;
 +            if (bracket_count > 32) {
 +                log_warning("Excessive bracket nesting detected");
 +                return false;
 +            }
 +        }
 +    }
++
 +    return true;
 +}
++
 +/* Internal helper functions implementation continues... */
++
 +/* Find section in document */
 +static toml_section_t *find_section(toml_document_t *doc, const char *section_name) {
 +    if (!doc || !section_name) return NULL;
++
 +    for (size_t i = 0; i < doc->section_count; i++) {
 +        if (strcmp(doc->sections[i].name, section_name) == 0) {
 +            return &doc->sections[i];
 +        }
 +    }
++
 +    return NULL;
 +}
++
 +/* Find or create section */
 +static toml_section_t *find_or_create_section(toml_document_t *doc, const char *section_name) {
 +    toml_section_t *section;
++
 +    if (!doc || !section_name) return NULL;
++
 +    /* Try to find existing section */
 +    section = find_section(doc, section_name);
 +    if (section) return section;
++
 +    /* Create new section */
 +    if (doc->section_count >= TOML_MAX_SECTIONS) {
 +        log_error("Maximum number of sections exceeded: %d", TOML_MAX_SECTIONS);
 +        return NULL;
 +    }
++
 +    section = &doc->sections[doc->section_count];
 +    memset(section, 0, sizeof(toml_section_t));
++
 +    safe_strncpy(section->name, section_name, sizeof(section->name));
 +    section->is_set = true;
 +    section->key_count = 0;
++
 +    doc->section_count++;
++
 +    return section;
 +}
++
 +/* Find key in section */
 +static toml_keyvalue_t *find_key(toml_section_t *section, const char *key_name) {
 +    if (!section || !key_name) return NULL;
++
 +    for (size_t i = 0; i < section->key_count; i++) {
 +        if (strcmp(section->keys[i].key, key_name) == 0) {
 +            return &section->keys[i];
 +        }
 +    }
++
 +    return NULL;
 +}
++
 +/* Parse section header [section.name] */
 +static int parse_section_header(toml_parser_state_t *state, char *section_name) {
 +    size_t name_pos = 0;
++
 +    if (!match_char(state, '[')) {
 +        set_parser_error(state, "Expected '[' at start of section");
 +        return -1;
 +    }
++
 +    skip_whitespace(state);
++
 +    /* Parse section name */
 +    while (!is_at_end(state) && current_char(state) != ']' &&
 +           name_pos < TOML_MAX_SECTION_LEN - 1) {
 +        char c = advance_char(state);
++
 +        if (isalnum(c) || c == '.' || c == '_' || c == '-') {
 +            section_name[name_pos++] = c;
 +        } else {
 +            set_parser_error(state, "Invalid character in section name");
 +            return -1;
 +        }
 +    }
++
 +    section_name[name_pos] = '\0';
++
 +    skip_whitespace(state);
++
 +    if (!match_char(state, ']')) {
 +        set_parser_error(state, "Expected ']' at end of section");
 +        return -1;
 +    }
++
 +    return 0;
 +}
++
 +/* Parse key-value pair */
 +static int parse_key_value_pair(toml_parser_state_t *state, toml_keyvalue_t *kv) {
 +    size_t key_pos = 0;
++
 +    memset(kv, 0, sizeof(toml_keyvalue_t));
++
 +    /* Parse key name */
 +    while (!is_at_end(state) && current_char(state) != '=' &&
 +           key_pos < TOML_MAX_KEY_LEN - 1) {
 +        char c = current_char(state);
++
 +        if (isalnum(c) || c == '_') {
 +            kv->key[key_pos++] = advance_char(state);
 +        } else if (isspace(c)) {
 +            advance_char(state);
 +            break;
 +        } else {
 +            set_parser_error(state, "Invalid character in key name");
 +            return -1;
 +        }
 +    }
++
 +    kv->key[key_pos] = '\0';
++
 +    skip_whitespace(state);
++
 +    if (!match_char(state, '=')) {
 +        set_parser_error(state, "Expected '=' after key name");
 +        return -1;
 +    }
++
 +    skip_whitespace(state);
++
 +    /* Determine value type and parse */
 +    char c = current_char(state);
++
 +    if (c == '"') {
 +        /* String value */
 +        kv->type = TOML_TYPE_STRING;
 +        return parse_string_value(state, kv->value, sizeof(kv->value));
 +    } else if (c == 't' || c == 'f') {
 +        /* Boolean value */
 +        kv->type = TOML_TYPE_BOOLEAN;
 +        bool bool_val;
 +        if (parse_boolean_value(state, &bool_val) == 0) {
 +            strcpy(kv->value, bool_val ? "true" : "false");
 +            kv->is_set = true;
 +            return 0;
 +        }
 +        return -1;
 +    } else if (isdigit(c) || c == '-' || c == '+') {
 +        /* Integer value */
 +        kv->type = TOML_TYPE_INTEGER;
 +        int int_val;
 +        if (parse_integer_value(state, &int_val) == 0) {
 +            snprintf(kv->value, sizeof(kv->value), "%d", int_val);
 +            kv->is_set = true;
 +            return 0;
 +        }
 +        return -1;
 +    } else {
 +        set_parser_error(state, "Invalid value type");
 +        return -1;
 +    }
 +}
++
 +/* Parse string value "..." */
 +static int parse_string_value(toml_parser_state_t *state, char *value, size_t value_size) {
 +    size_t value_pos = 0;
++
 +    if (!match_char(state, '"')) {
 +        set_parser_error(state, "Expected '\"' at start of string");
 +        return -1;
 +    }
++
 +    while (!is_at_end(state) && current_char(state) != '"' &&
 +           value_pos < value_size - 1) {
 +        char c = advance_char(state);
++
 +        /* Handle escape sequences */
 +        if (c == '\\' && !is_at_end(state)) {
 +            char next = advance_char(state);
 +            switch (next) {
 +                case 'n': value[value_pos++] = '\n'; break;
 +                case 't': value[value_pos++] = '\t'; break;
 +                case 'r': value[value_pos++] = '\r'; break;
 +                case '\\': value[value_pos++] = '\\'; break;
 +                case '"': value[value_pos++] = '"'; break;
 +                default:
 +                    set_parser_error(state, "Invalid escape sequence");
 +                    return -1;
 +            }
 +        } else {
 +            value[value_pos++] = c;
 +        }
 +    }
++
 +    value[value_pos] = '\0';
++
 +    if (!match_char(state, '"')) {
 +        set_parser_error(state, "Expected '\"' at end of string");
 +        return -1;
 +    }
++
 +    return 0;
 +}
++
 +/* Parse boolean value true/false */
 +static int parse_boolean_value(toml_parser_state_t *state, bool *value) {
 +    if (strncmp(&state->input[state->position], "true", 4) == 0) {
 +        state->position += 4;
 +        *value = true;
 +        return 0;
 +    } else if (strncmp(&state->input[state->position], "false", 5) == 0) {
 +        state->position += 5;
 +        *value = false;
 +        return 0;
 +    } else {
 +        set_parser_error(state, "Invalid boolean value");
 +        return -1;
 +    }
 +}
++
 +/* Parse integer value */
 +static int parse_integer_value(toml_parser_state_t *state, int *value) {
 +    char num_str[32];
 +    size_t num_pos = 0;
 +    char *endptr;
 +    long parsed_value;
++
 +    /* Handle optional sign */
 +    char c = current_char(state);
 +    if (c == '+' || c == '-') {
 +        num_str[num_pos++] = advance_char(state);
 +    }
++
 +    /* Parse digits */
 +    while (!is_at_end(state) && isdigit(current_char(state)) &&
 +           num_pos < sizeof(num_str) - 1) {
 +        num_str[num_pos++] = advance_char(state);
 +    }
++
 +    num_str[num_pos] = '\0';
++
 +    if (num_pos == 0 || (num_pos == 1 && (num_str[0] == '+' || num_str[0] == '-'))) {
 +        set_parser_error(state, "Invalid integer format");
 +        return -1;
 +    }
++
 +    errno = 0;
 +    parsed_value = strtol(num_str, &endptr, 10);
++
 +    if (errno != 0 || *endptr != '\0') {
 +        set_parser_error(state, "Integer parsing error");
 +        return -1;
 +    }
++
 +    if (parsed_value < INT_MIN || parsed_value > INT_MAX) {
 +        set_parser_error(state, "Integer out of range");
 +        return -1;
 +    }
++
 +    *value = (int)parsed_value;
 +    return 0;
 +}
++
 +/* Parsing helper functions */
++
 +static void skip_whitespace(toml_parser_state_t *state) {
 +    while (!is_at_end(state)) {
 +        char c = current_char(state);
 +        if (c == ' ' || c == '\t') {
 +            advance_char(state);
 +        } else {
 +            break;
 +        }
 +    }
 +}
++
 +static void skip_comment(toml_parser_state_t *state) {
 +    while (!is_at_end(state) && current_char(state) != '\n') {
 +        advance_char(state);
 +    }
 +    if (!is_at_end(state)) {
 +        advance_char(state); /* Skip the newline */
 +    }
 +}
++
 +static bool is_at_end(const toml_parser_state_t *state) {
 +    return state->position >= state->input_length;
 +}
++
 +static char current_char(const toml_parser_state_t *state) {
 +    if (is_at_end(state)) return '\0';
 +    return state->input[state->position];
 +}
++
 +static char advance_char(toml_parser_state_t *state) {
 +    if (is_at_end(state)) return '\0';
++
 +    char c = state->input[state->position++];
++
 +    if (c == '\n') {
 +        state->line_number++;
 +        state->column_number = 1;
 +    } else {
 +        state->column_number++;
 +    }
++
 +    return c;
 +}
++
 +static bool match_char(toml_parser_state_t *state, char expected) {
 +    if (is_at_end(state) || current_char(state) != expected) {
 +        return false;
 +    }
 +    advance_char(state);
 +    return true;
 +}
++
 +static void set_parser_error(toml_parser_state_t *state, const char *message) {
 +    state->has_error = true;
 +    safe_strncpy(state->error_message, message, sizeof(state->error_message));
 +}
++
 +/* Get all sections from document */
 +int toml_get_sections(const toml_document_t *doc, char sections[][TOML_MAX_SECTION_LEN],
 +                      size_t max_sections, size_t *section_count) {
 +    if (!doc || !sections || !section_count) {
 +        set_error(ERR_INVALID_ARGS, "Invalid arguments to toml_get_sections");
 +        return -1;
 +    }
++
 +    *section_count = 0;
++
 +    for (size_t i = 0; i < doc->section_count && *section_count < max_sections; i++) {
 +        safe_strncpy(sections[*section_count], doc->sections[i].name, TOML_MAX_SECTION_LEN);
 +        (*section_count)++;
 +    }
++
 +    return 0;
 +}
++
 +/* Set string value in document */
 +int toml_set_string(toml_document_t *doc, const char *section_name,
 +                    const char *key_name, const char *value) {
 +    toml_section_t *section;
 +    toml_keyvalue_t *kv;
++
 +    if (!doc || !section_name || !key_name || !value) {
 +        set_error(ERR_INVALID_ARGS, "Invalid arguments to toml_set_string");
 +        return -1;
 +    }
++
 +    /* Find or create section */
 +    section = find_or_create_section(doc, section_name);
 +    if (!section) {
 +        return -1;
 +    }
++
 +    /* Find or create key */
 +    kv = find_key(section, key_name);
 +    if (!kv) {
 +        /* Create new key-value pair */
 +        if (section->key_count >= TOML_MAX_KEYS_PER_SECTION) {
 +            set_error(ERR_CONFIG_INVALID, "Too many key-value pairs in section: %s", section_name);
 +            return -1;
 +        }
++
 +        kv = &section->keys[section->key_count];
 +        safe_strncpy(kv->key, key_name, sizeof(kv->key));
 +        section->key_count++;
 +    }
++
 +    /* Set string value */
 +    kv->type = TOML_TYPE_STRING;
 +    safe_strncpy(kv->value, value, sizeof(kv->value));
 +    kv->is_set = true;
++
 +    return 0;
 +}
++
 +/* Set boolean value in document */
 +int toml_set_boolean(toml_document_t *doc, const char *section_name,
 +                     const char *key_name, bool value) {
 +    toml_section_t *section;
 +    toml_keyvalue_t *kv;
++
 +    if (!doc || !section_name || !key_name) {
 +        set_error(ERR_INVALID_ARGS, "Invalid arguments to toml_set_boolean");
 +        return -1;
 +    }
++
 +    /* Find or create section */
 +    section = find_or_create_section(doc, section_name);
 +    if (!section) {
 +        return -1;
 +    }
++
 +    /* Find or create key */
 +    kv = find_key(section, key_name);
 +    if (!kv) {
 +        /* Create new key-value pair */
 +        if (section->key_count >= TOML_MAX_KEYS_PER_SECTION) {
 +            set_error(ERR_CONFIG_INVALID, "Too many key-value pairs in section: %s", section_name);
 +            return -1;
 +        }
++
 +        kv = &section->keys[section->key_count];
 +        safe_strncpy(kv->key, key_name, sizeof(kv->key));
 +        section->key_count++;
 +    }
++
 +    /* Set boolean value */
 +    kv->type = TOML_TYPE_BOOLEAN;
 +    safe_strncpy(kv->value, value ? "true" : "false", sizeof(kv->value));
 +    kv->is_set = true;
++
 +    return 0;
 +}
++
 +/* Write document to file */
 +int toml_write_file(const toml_document_t *doc, const char *file_path) {
 +    FILE *file;
++
 +    if (!doc || !file_path) {
 +        set_error(ERR_INVALID_ARGS, "Invalid arguments to toml_write_file");
 +        return -1;
 +    }
++
 +    file = fopen(file_path, "w");
 +    if (!file) {
 +        set_system_error(ERR_CONFIG_WRITE_FAILED, "Failed to open file for writing: %s", file_path);
 +        return -1;
 +    }
++
 +    /* Write sections */
 +    for (size_t i = 0; i < doc->section_count; i++) {
 +        const toml_section_t *section = &doc->sections[i];
++
 +        /* Write section header */
 +        if (fprintf(file, "[%s]\n", section->name) < 0) {
 +            fclose(file);
 +            set_system_error(ERR_CONFIG_WRITE_FAILED, "Failed to write section header");
 +            return -1;
 +        }
++
 +        /* Write key-value pairs */
 +        for (size_t j = 0; j < section->key_count; j++) {
 +            const toml_keyvalue_t *kv = &section->keys[j];
++
 +            if (!kv->is_set) continue;
++
 +            switch (kv->type) {
 +                case TOML_TYPE_STRING:
 +                    if (fprintf(file, "%s = \"%s\"\n", kv->key, kv->value) < 0) {
 +                        fclose(file);
 +                        set_system_error(ERR_CONFIG_WRITE_FAILED, "Failed to write string value");
 +                        return -1;
 +                    }
 +                    break;
++
 +                case TOML_TYPE_INTEGER:
 +                case TOML_TYPE_BOOLEAN:
 +                    if (fprintf(file, "%s = %s\n", kv->key, kv->value) < 0) {
 +                        fclose(file);
 +                        set_system_error(ERR_CONFIG_WRITE_FAILED, "Failed to write value");
 +                        return -1;
 +                    }
 +                    break;
++
 +                case TOML_TYPE_INVALID:
 +                default:
 +                    break;
 +            }
 +        }
++
 +        /* Add blank line between sections */
 +        if (i < doc->section_count - 1) {
 +            fprintf(file, "\n");
 +        }
 +    }
++
 +    fclose(file);
 +    return 0;
 +}
++
 +/* Cleanup TOML document */
 +void toml_cleanup_document(toml_document_t *doc) {
 +    if (!doc) return;
++
 +    /* Clear sensitive data */
 +    secure_zero_memory(doc, sizeof(toml_document_t));
 +}

src/utils.cadded

1126 lines changed — click to load

 +/* Utility functions and helpers with security focus
 + * Provides secure, validated utility functions for gitswitch-c
 + */
++
 +#define _GNU_SOURCE
 +#include <stdio.h>
 +#include <stdlib.h>
 +#include <string.h>
 +#include <unistd.h>
 +#include <sys/stat.h>
 +#include <sys/types.h>
 +#include <sys/wait.h>
 +#include <sys/ioctl.h>
 +#include <fcntl.h>
 +#include <errno.h>
 +#include <pwd.h>
 +#include <termios.h>
 +#include <time.h>
 +#include <ctype.h>
 +#include <signal.h>
 +#include <regex.h>
++
 +#if defined(__linux__)
 +#include <sys/mman.h>
 +#include <linux/random.h>
 +#include <sys/syscall.h>
 +#endif
++
 +#include "utils.h"
 +#include "error.h"
++
 +/* Static variables for terminal state management */
 +static struct termios g_original_termios;
 +static bool g_echo_disabled = false;
++
 +/* Cleanup handlers registry */
 +static void (*g_cleanup_handlers[16])(void);
 +static size_t g_cleanup_handler_count = 0;
++
 +/* String utilities */
++
 +char *trim_whitespace(char *str) {
 +    char *end;
++
 +    if (!str) return NULL;
++
 +    /* Trim leading space */
 +    while (isspace((unsigned char)*str)) str++;
++
 +    /* All spaces? */
 +    if (*str == '\0') return str;
++
 +    /* Trim trailing space */
 +    end = str + strlen(str) - 1;
 +    while (end > str && isspace((unsigned char)*end)) end--;
++
 +    /* Write new null terminator */
 +    end[1] = '\0';
++
 +    return str;
 +}
++
 +bool string_empty(const char *str) {
 +    return !str || *str == '\0';
 +}
++
 +bool string_equals(const char *a, const char *b) {
 +    if (!a && !b) return true;
 +    if (!a || !b) return false;
 +    return strcmp(a, b) == 0;
 +}
++
 +bool string_starts_with(const char *str, const char *prefix) {
 +    if (!str || !prefix) return false;
 +    return strncmp(str, prefix, strlen(prefix)) == 0;
 +}
++
 +bool string_ends_with(const char *str, const char *suffix) {
 +    if (!str || !suffix) return false;
++
 +    size_t str_len = strlen(str);
 +    size_t suffix_len = strlen(suffix);
++
 +    if (suffix_len > str_len) return false;
++
 +    return strcmp(str + str_len - suffix_len, suffix) == 0;
 +}
++
 +int string_replace(char *str, size_t str_size, const char *old, const char *new) {
 +    if (!str || !old || !new) {
 +        set_error(ERR_INVALID_ARGS, "NULL arguments to string_replace");
 +        return -1;
 +    }
++
 +    char *pos = strstr(str, old);
 +    if (!pos) return 0; /* No replacement needed */
++
 +    size_t old_len = strlen(old);
 +    size_t new_len = strlen(new);
 +    size_t str_len = strlen(str);
++
 +    /* Check if replacement would overflow buffer */
 +    if (str_len - old_len + new_len >= str_size) {
 +        set_error(ERR_INVALID_ARGS, "String replacement would overflow buffer");
 +        return -1;
 +    }
++
 +    /* Move the rest of the string */
 +    memmove(pos + new_len, pos + old_len, strlen(pos + old_len) + 1);
++
 +    /* Copy new string */
 +    memcpy(pos, new, new_len);
++
 +    return 1;
 +}
++
 +/* Path utilities */
++
 +int expand_path(const char *path, char *expanded_path, size_t path_size) {
 +    if (!path || !expanded_path || path_size == 0) {
 +        set_error(ERR_INVALID_ARGS, "Invalid arguments to expand_path");
 +        return -1;
 +    }
++
 +    /* Handle tilde expansion */
 +    if (path[0] == '~') {
 +        char home_path[MAX_PATH_LEN];
++
 +        if (get_home_directory(home_path, sizeof(home_path)) != 0) {
 +            return -1;
 +        }
++
 +        /* Handle ~/path and ~/ cases */
 +        const char *rest = (path[1] == '/') ? path + 2 : path + 1;
++
 +        if (snprintf(expanded_path, path_size, "%s/%s", home_path, rest) >= (int)path_size) {
 +            set_error(ERR_INVALID_ARGS, "Expanded path too long");
 +            return -1;
 +        }
 +    } else {
 +        /* Path doesn't need expansion */
 +        if (strlen(path) >= path_size) {
 +            set_error(ERR_INVALID_ARGS, "Path too long for buffer");
 +            return -1;
 +        }
 +        strcpy(expanded_path, path);
 +    }
++
 +    return 0;
 +}
++
 +int get_home_directory(char *home_path, size_t path_size) {
 +    const char *home = getenv("HOME");
++
 +    if (!home) {
 +        /* Fall back to password database */
 +        struct passwd *pw = getpwuid(getuid());
 +        if (!pw) {
 +            set_system_error(ERR_SYSTEM_CALL, "Failed to get user home directory");
 +            return -1;
 +        }
 +        home = pw->pw_dir;
 +    }
++
 +    if (strlen(home) >= path_size) {
 +        set_error(ERR_INVALID_ARGS, "Home directory path too long");
 +        return -1;
 +    }
++
 +    strcpy(home_path, home);
 +    return 0;
 +}
++
 +int join_path(char *result, size_t result_size, const char *base, const char *component) {
 +    if (!result || !base || !component || result_size == 0) {
 +        set_error(ERR_INVALID_ARGS, "Invalid arguments to join_path");
 +        return -1;
 +    }
++
 +    size_t base_len = strlen(base);
 +    size_t comp_len = strlen(component);
 +    bool needs_separator = (base_len > 0 && base[base_len - 1] != '/') &&
 +                          (comp_len > 0 && component[0] != '/');
++
 +    size_t total_len = base_len + comp_len + (needs_separator ? 1 : 0);
++
 +    if (total_len >= result_size) {
 +        set_error(ERR_INVALID_ARGS, "Joined path too long for buffer");
 +        return -1;
 +    }
++
 +    strcpy(result, base);
 +    if (needs_separator) {
 +        strcat(result, "/");
 +    }
 +    strcat(result, component);
++
 +    return 0;
 +}
++
 +bool path_exists(const char *path) {
 +    struct stat st;
 +    return path && stat(path, &st) == 0;
 +}
++
 +bool is_directory(const char *path) {
 +    struct stat st;
 +    return path && stat(path, &st) == 0 && S_ISDIR(st.st_mode);
 +}
++
 +bool is_regular_file(const char *path) {
 +    struct stat st;
 +    return path && stat(path, &st) == 0 && S_ISREG(st.st_mode);
 +}
++
 +int create_directory_recursive(const char *path, mode_t mode) {
 +    if (!path) {
 +        set_error(ERR_INVALID_ARGS, "NULL path to create_directory_recursive");
 +        return -1;
 +    }
++
 +    char temp_path[MAX_PATH_LEN];
 +    char *p = NULL;
 +    size_t len;
++
 +    if (snprintf(temp_path, sizeof(temp_path), "%s", path) >= sizeof(temp_path)) {
 +        set_error(ERR_INVALID_ARGS, "Path too long");
 +        return -1;
 +    }
++
 +    len = strlen(temp_path);
 +    if (temp_path[len - 1] == '/') {
 +        temp_path[len - 1] = '\0';
 +    }
++
 +    for (p = temp_path + 1; *p; p++) {
 +        if (*p == '/') {
 +            *p = '\0';
 +            if (mkdir(temp_path, mode) != 0 && errno != EEXIST) {
 +                set_system_error(ERR_FILE_IO, "Failed to create directory: %s", temp_path);
 +                return -1;
 +            }
 +            *p = '/';
 +        }
 +    }
++
 +    if (mkdir(temp_path, mode) != 0 && errno != EEXIST) {
 +        set_system_error(ERR_FILE_IO, "Failed to create directory: %s", temp_path);
 +        return -1;
 +    }
++
 +    return 0;
 +}
++
 +int get_file_permissions(const char *path, mode_t *mode) {
 +    struct stat st;
++
 +    if (!path || !mode) {
 +        set_error(ERR_INVALID_ARGS, "Invalid arguments to get_file_permissions");
 +        return -1;
 +    }
++
 +    if (stat(path, &st) != 0) {
 +        set_system_error(ERR_FILE_IO, "Failed to stat file: %s", path);
 +        return -1;
 +    }
++
 +    *mode = st.st_mode & 07777; /* Only permission bits */
 +    return 0;
 +}
++
 +int set_file_permissions(const char *path, mode_t mode) {
 +    if (!path) {
 +        set_error(ERR_INVALID_ARGS, "NULL path to set_file_permissions");
 +        return -1;
 +    }
++
 +    if (chmod(path, mode) != 0) {
 +        set_system_error(ERR_PERMISSION_DENIED, "Failed to set permissions on: %s", path);
 +        return -1;
 +    }
++
 +    return 0;
 +}
++
 +/* File utilities */
++
 +int read_file_to_string(const char *file_path, char *buffer, size_t buffer_size) {
 +    FILE *file;
 +    size_t bytes_read;
++
 +    if (!file_path || !buffer || buffer_size == 0) {
 +        set_error(ERR_INVALID_ARGS, "Invalid arguments to read_file_to_string");
 +        return -1;
 +    }
++
 +    file = fopen(file_path, "r");
 +    if (!file) {
 +        set_system_error(ERR_FILE_IO, "Failed to open file for reading: %s", file_path);
 +        return -1;
 +    }
++
 +    bytes_read = fread(buffer, 1, buffer_size - 1, file);
 +    if (ferror(file)) {
 +        set_system_error(ERR_FILE_IO, "Failed to read from file: %s", file_path);
 +        fclose(file);
 +        return -1;
 +    }
++
 +    buffer[bytes_read] = '\0';
 +    fclose(file);
++
 +    return (int)bytes_read;
 +}
++
 +int write_string_to_file(const char *file_path, const char *content, mode_t mode) {
 +    FILE *file;
 +    size_t content_len, bytes_written;
++
 +    if (!file_path || !content) {
 +        set_error(ERR_INVALID_ARGS, "Invalid arguments to write_string_to_file");
 +        return -1;
 +    }
++
 +    file = fopen(file_path, "w");
 +    if (!file) {
 +        set_system_error(ERR_FILE_IO, "Failed to open file for writing: %s", file_path);
 +        return -1;
 +    }
++
 +    content_len = strlen(content);
 +    bytes_written = fwrite(content, 1, content_len, file);
++
 +    if (bytes_written != content_len) {
 +        set_system_error(ERR_FILE_IO, "Failed to write complete content to: %s", file_path);
 +        fclose(file);
 +        return -1;
 +    }
++
 +    fclose(file);
++
 +    /* Set file permissions */
 +    if (set_file_permissions(file_path, mode) != 0) {
 +        return -1;
 +    }
++
 +    return 0;
 +}
++
 +int copy_file(const char *src_path, const char *dst_path) {
 +    FILE *src, *dst;
 +    char buffer[4096];
 +    size_t bytes;
 +    int result = 0;
++
 +    if (!src_path || !dst_path) {
 +        set_error(ERR_INVALID_ARGS, "Invalid arguments to copy_file");
 +        return -1;
 +    }
++
 +    src = fopen(src_path, "rb");
 +    if (!src) {
 +        set_system_error(ERR_FILE_IO, "Failed to open source file: %s", src_path);
 +        return -1;
 +    }
++
 +    dst = fopen(dst_path, "wb");
 +    if (!dst) {
 +        set_system_error(ERR_FILE_IO, "Failed to open destination file: %s", dst_path);
 +        fclose(src);
 +        return -1;
 +    }
++
 +    while ((bytes = fread(buffer, 1, sizeof(buffer), src)) > 0) {
 +        if (fwrite(buffer, 1, bytes, dst) != bytes) {
 +            set_system_error(ERR_FILE_IO, "Failed to write to destination file: %s", dst_path);
 +            result = -1;
 +            break;
 +        }
 +    }
++
 +    if (ferror(src)) {
 +        set_system_error(ERR_FILE_IO, "Error reading source file: %s", src_path);
 +        result = -1;
 +    }
++
 +    fclose(src);
 +    fclose(dst);
++
 +    /* Copy permissions from source to destination */
 +    if (result == 0) {
 +        struct stat src_stat;
 +        if (stat(src_path, &src_stat) == 0) {
 +            chmod(dst_path, src_stat.st_mode);
 +        }
 +    }
++
 +    return result;
 +}
++
 +int backup_file(const char *file_path, const char *backup_suffix) {
 +    char backup_path[MAX_PATH_LEN];
++
 +    if (!file_path || !backup_suffix) {
 +        set_error(ERR_INVALID_ARGS, "Invalid arguments to backup_file");
 +        return -1;
 +    }
++
 +    if (snprintf(backup_path, sizeof(backup_path), "%s%s",
 +                file_path, backup_suffix) >= sizeof(backup_path)) {
 +        set_error(ERR_INVALID_ARGS, "Backup path too long");
 +        return -1;
 +    }
++
 +    return copy_file(file_path, backup_path);
 +}
++
 +bool file_is_readable(const char *file_path) {
 +    return file_path && access(file_path, R_OK) == 0;
 +}
++
 +bool file_is_writable(const char *file_path) {
 +    return file_path && access(file_path, W_OK) == 0;
 +}
++
 +size_t get_file_size(const char *file_path) {
 +    struct stat st;
++
 +    if (!file_path || stat(file_path, &st) != 0) {
 +        return 0;
 +    }
++
 +    return (size_t)st.st_size;
 +}
++
 +time_t get_file_mtime(const char *file_path) {
 +    struct stat st;
++
 +    if (!file_path || stat(file_path, &st) != 0) {
 +        return 0;
 +    }
++
 +    return st.st_mtime;
 +}
++
 +/* Process utilities */
++
 +int execute_command(const char *command, char *output, size_t output_size) {
 +    return execute_command_with_input(command, NULL, output, output_size);
 +}
++
 +int execute_command_with_input(const char *command, const char *input,
 +                               char *output, size_t output_size) {
 +    FILE *pipe;
 +    char *line = NULL;
 +    size_t len = 0;
 +    ssize_t read_len;
 +    int status;
++
 +    if (!command) {
 +        set_error(ERR_INVALID_ARGS, "NULL command to execute_command_with_input");
 +        return -1;
 +    }
++
 +    /* Clear output buffer */
 +    if (output && output_size > 0) {
 +        output[0] = '\0';
 +    }
++
 +    pipe = popen(command, "r");
 +    if (!pipe) {
 +        set_system_error(ERR_SYSTEM_CALL, "Failed to execute command: %s", command);
 +        return -1;
 +    }
++
 +    /* Write input to command if provided */
 +    if (input) {
 +        /* Note: This is simplified - full implementation would need bidirectional pipes */
 +        log_warning("Input to command not fully implemented yet");
 +    }
++
 +    /* Read output */
 +    if (output && output_size > 0) {
 +        size_t total_read = 0;
++
 +        while ((read_len = getline(&line, &len, pipe)) != -1 &&
 +               total_read < output_size - 1) {
++
 +            size_t to_copy = (size_t)read_len;
 +            if (total_read + to_copy >= output_size) {
 +                to_copy = output_size - total_read - 1;
 +            }
++
 +            memcpy(output + total_read, line, to_copy);
 +            total_read += to_copy;
 +        }
++
 +        output[total_read] = '\0';
++
 +        /* Remove trailing newline if present */
 +        if (total_read > 0 && output[total_read - 1] == '\n') {
 +            output[total_read - 1] = '\0';
 +        }
 +    }
++
 +    free(line);
 +    status = pclose(pipe);
++
 +    if (status == -1) {
 +        set_system_error(ERR_SYSTEM_CALL, "pclose failed for command: %s", command);
 +        return -1;
 +    }
++
 +    return WEXITSTATUS(status);
 +}
++
 +bool command_exists(const char *command) {
 +    char test_command[256];
 +    int result;
++
 +    if (!command) return false;
++
 +    if (snprintf(test_command, sizeof(test_command),
 +                "command -v %s >/dev/null 2>&1", command) >= sizeof(test_command)) {
 +        return false;
 +    }
++
 +    result = system(test_command);
 +    return result == 0;
 +}
++
 +pid_t start_background_process(const char *command, char *pidfile_path) {
 +    pid_t pid;
 +    FILE *pidfile;
++
 +    if (!command) {
 +        set_error(ERR_INVALID_ARGS, "NULL command to start_background_process");
 +        return -1;
 +    }
++
 +    pid = fork();
 +    if (pid == -1) {
 +        set_system_error(ERR_SYSTEM_CALL, "Failed to fork process");
 +        return -1;
 +    }
++
 +    if (pid == 0) {
 +        /* Child process */
 +        setsid(); /* Create new session */
++
 +        /* Redirect standard streams */
 +        freopen("/dev/null", "r", stdin);
 +        freopen("/dev/null", "w", stdout);
 +        freopen("/dev/null", "w", stderr);
++
 +        /* Execute command */
 +        execl("/bin/sh", "sh", "-c", command, (char *)NULL);
 +        _exit(127); /* If exec fails */
 +    }
++
 +    /* Parent process */
 +    if (pidfile_path) {
 +        pidfile = fopen(pidfile_path, "w");
 +        if (pidfile) {
 +            fprintf(pidfile, "%d\n", pid);
 +            fclose(pidfile);
 +        }
 +    }
++
 +    return pid;
 +}
++
 +int kill_process_by_pidfile(const char *pidfile_path) {
 +    FILE *pidfile;
 +    pid_t pid;
++
 +    if (!pidfile_path) {
 +        set_error(ERR_INVALID_ARGS, "NULL pidfile path");
 +        return -1;
 +    }
++
 +    pidfile = fopen(pidfile_path, "r");
 +    if (!pidfile) {
 +        set_system_error(ERR_FILE_IO, "Failed to open pidfile: %s", pidfile_path);
 +        return -1;
 +    }
++
 +    if (fscanf(pidfile, "%d", &pid) != 1) {
 +        set_error(ERR_FILE_IO, "Failed to read PID from file: %s", pidfile_path);
 +        fclose(pidfile);
 +        return -1;
 +    }
++
 +    fclose(pidfile);
++
 +    if (pid <= 0) {
 +        set_error(ERR_INVALID_ARGS, "Invalid PID in file: %d", pid);
 +        return -1;
 +    }
++
 +    if (kill(pid, SIGTERM) != 0) {
 +        if (errno == ESRCH) {
 +            /* Process doesn't exist - clean up pidfile */
 +            unlink(pidfile_path);
 +            return 0;
 +        }
 +        set_system_error(ERR_SYSTEM_CALL, "Failed to kill process %d", pid);
 +        return -1;
 +    }
++
 +    /* Clean up pidfile */
 +    unlink(pidfile_path);
++
 +    return 0;
 +}
++
 +bool process_is_running(pid_t pid) {
 +    if (pid <= 0) return false;
 +    return kill(pid, 0) == 0;
 +}
++
 +/* Environment utilities */
++
 +int get_env_var(const char *name, char *buffer, size_t buffer_size) {
 +    const char *value;
++
 +    if (!name || !buffer || buffer_size == 0) {
 +        set_error(ERR_INVALID_ARGS, "Invalid arguments to get_env_var");
 +        return -1;
 +    }
++
 +    value = getenv(name);
 +    if (!value) {
 +        buffer[0] = '\0';
 +        return 1; /* Not an error, just not found */
 +    }
++
 +    if (strlen(value) >= buffer_size) {
 +        set_error(ERR_INVALID_ARGS, "Environment variable value too long");
 +        return -1;
 +    }
++
 +    strcpy(buffer, value);
 +    return 0;
 +}
++
 +int set_env_var(const char *name, const char *value, bool overwrite) {
 +    if (!name || !value) {
 +        set_error(ERR_INVALID_ARGS, "Invalid arguments to set_env_var");
 +        return -1;
 +    }
++
 +    if (setenv(name, value, overwrite ? 1 : 0) != 0) {
 +        set_system_error(ERR_SYSTEM_CALL, "Failed to set environment variable: %s", name);
 +        return -1;
 +    }
++
 +    return 0;
 +}
++
 +int unset_env_var(const char *name) {
 +    if (!name) {
 +        set_error(ERR_INVALID_ARGS, "NULL name to unset_env_var");
 +        return -1;
 +    }
++
 +    if (unsetenv(name) != 0) {
 +        set_system_error(ERR_SYSTEM_CALL, "Failed to unset environment variable: %s", name);
 +        return -1;
 +    }
++
 +    return 0;
 +}
++
 +/* Validation utilities */
++
 +bool validate_email(const char *email) {
 +    regex_t regex;
 +    int result;
++
 +    if (!email || strlen(email) > MAX_EMAIL_LEN) {
 +        return false;
 +    }
++
 +    /* Basic email regex - not RFC compliant but good enough for git configs */
 +    const char *pattern = "^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$";
++
 +    result = regcomp(&regex, pattern, REG_EXTENDED);
 +    if (result) return false;
++
 +    result = regexec(&regex, email, 0, NULL, 0);
 +    regfree(&regex);
++
 +    return result == 0;
 +}
++
 +bool validate_name(const char *name) {
 +    if (!name || strlen(name) == 0 || strlen(name) >= MAX_NAME_LEN) {
 +        return false;
 +    }
++
 +    /* Name should contain at least one non-whitespace character */
 +    for (const char *p = name; *p; p++) {
 +        if (!isspace((unsigned char)*p)) {
 +            return true;
 +        }
 +    }
++
 +    return false;
 +}
++
 +bool validate_key_id(const char *key_id) {
 +    if (!key_id || strlen(key_id) == 0 || strlen(key_id) >= MAX_KEY_ID_LEN) {
 +        return false;
 +    }
++
 +    /* Key ID should be hexadecimal */
 +    for (const char *p = key_id; *p; p++) {
 +        if (!isxdigit((unsigned char)*p)) {
 +            return false;
 +        }
 +    }
++
 +    return true;
 +}
++
 +bool validate_file_path(const char *path) {
 +    char expanded[MAX_PATH_LEN];
++
 +    if (!path || strlen(path) == 0 || strlen(path) >= MAX_PATH_LEN) {
 +        return false;
 +    }
++
 +    /* Expand path and check if it exists */
 +    if (expand_path(path, expanded, sizeof(expanded)) != 0) {
 +        return false;
 +    }
++
 +    return path_exists(expanded);
 +}
++
 +/* Security utilities */
++
 +void secure_zero_memory(void *ptr, size_t size) {
 +    if (!ptr || size == 0) return;
++
 +    /* Use explicit_bzero if available, otherwise volatile memset */
 +#ifdef __GLIBC__
 +    explicit_bzero(ptr, size);
 +#else
 +    volatile unsigned char *p = ptr;
 +    while (size--) {
 +        *p++ = 0;
 +    }
 +#endif
 +}
++
 +int generate_random_string(char *buffer, size_t buffer_size, const char *charset) {
 +    size_t charset_len;
 +    size_t i;
 +    FILE *urandom;
++
 +    if (!buffer || buffer_size == 0 || !charset) {
 +        set_error(ERR_INVALID_ARGS, "Invalid arguments to generate_random_string");
 +        return -1;
 +    }
++
 +    charset_len = strlen(charset);
 +    if (charset_len == 0) {
 +        set_error(ERR_INVALID_ARGS, "Empty charset");
 +        return -1;
 +    }
++
 +    urandom = fopen("/dev/urandom", "rb");
 +    if (!urandom) {
 +        set_system_error(ERR_FILE_IO, "Failed to open /dev/urandom");
 +        return -1;
 +    }
++
 +    for (i = 0; i < buffer_size - 1; i++) {
 +        unsigned char rand_byte;
 +        if (fread(&rand_byte, 1, 1, urandom) != 1) {
 +            set_system_error(ERR_FILE_IO, "Failed to read random data");
 +            fclose(urandom);
 +            return -1;
 +        }
 +        buffer[i] = charset[rand_byte % charset_len];
 +    }
++
 +    buffer[buffer_size - 1] = '\0';
 +    fclose(urandom);
++
 +    return 0;
 +}
++
 +bool check_file_permissions_safe(const char *file_path, mode_t expected_mode) {
 +    mode_t actual_mode;
++
 +    if (!file_path) return false;
++
 +    if (get_file_permissions(file_path, &actual_mode) != 0) {
 +        return false;
 +    }
++
 +    /* Check if permissions are as expected or more restrictive */
 +    return (actual_mode & 07777) == expected_mode;
 +}
++
 +/* Configuration utilities */
++
 +int get_config_directory(char *config_dir, size_t dir_size) {
 +    char home[MAX_PATH_LEN];
++
 +    if (!config_dir || dir_size == 0) {
 +        set_error(ERR_INVALID_ARGS, "Invalid arguments to get_config_directory");
 +        return -1;
 +    }
++
 +    if (get_home_directory(home, sizeof(home)) != 0) {
 +        return -1;
 +    }
++
 +    if (snprintf(config_dir, dir_size, "%s/%s", home, DEFAULT_CONFIG_DIR) >= (int)dir_size) {
 +        set_error(ERR_INVALID_ARGS, "Config directory path too long");
 +        return -1;
 +    }
++
 +    return 0;
 +}
++
 +int ensure_config_directory_exists(void) {
 +    char config_dir[MAX_PATH_LEN];
++
 +    if (get_config_directory(config_dir, sizeof(config_dir)) != 0) {
 +        return -1;
 +    }
++
 +    if (!is_directory(config_dir)) {
 +        if (create_directory_recursive(config_dir, PERM_USER_RWX) != 0) {
 +            return -1;
 +        }
 +        log_info("Created config directory: %s", config_dir);
 +    }
++
 +    return 0;
 +}
++
 +/* Terminal utilities */
++
 +bool is_terminal(int fd) {
 +    return isatty(fd) == 1;
 +}
++
 +int get_terminal_size(int *width, int *height) {
 +    struct winsize ws;
++
 +    if (!width || !height) {
 +        set_error(ERR_INVALID_ARGS, "NULL arguments to get_terminal_size");
 +        return -1;
 +    }
++
 +    if (ioctl(STDOUT_FILENO, TIOCGWINSZ, &ws) == -1) {
 +        set_system_error(ERR_SYSTEM_CALL, "Failed to get terminal size");
 +        return -1;
 +    }
++
 +    *width = ws.ws_col;
 +    *height = ws.ws_row;
++
 +    return 0;
 +}
++
 +void disable_echo(void) {
 +    struct termios new_termios;
++
 +    if (g_echo_disabled) return;
++
 +    if (tcgetattr(STDIN_FILENO, &g_original_termios) != 0) {
 +        return; /* Can't save original, don't disable echo */
 +    }
++
 +    new_termios = g_original_termios;
 +    new_termios.c_lflag &= ~ECHO;
++
 +    if (tcsetattr(STDIN_FILENO, TCSANOW, &new_termios) == 0) {
 +        g_echo_disabled = true;
 +    }
 +}
++
 +void enable_echo(void) {
 +    if (!g_echo_disabled) return;
++
 +    tcsetattr(STDIN_FILENO, TCSANOW, &g_original_termios);
 +    g_echo_disabled = false;
 +}
++
 +/* Time utilities */
++
 +void get_current_time_string(char *buffer, size_t buffer_size) {
 +    time_t now;
 +    struct tm *tm_info;
++
 +    if (!buffer || buffer_size == 0) return;
++
 +    time(&now);
 +    tm_info = localtime(&now);
++
 +    if (tm_info) {
 +        strftime(buffer, buffer_size, "%Y-%m-%d %H:%M:%S", tm_info);
 +    } else {
 +        strncpy(buffer, "UNKNOWN", buffer_size - 1);
 +        buffer[buffer_size - 1] = '\0';
 +    }
 +}
++
 +void get_timestamp_string(char *buffer, size_t buffer_size) {
 +    time_t now;
++
 +    if (!buffer || buffer_size == 0) return;
++
 +    time(&now);
 +    snprintf(buffer, buffer_size, "%ld", (long)now);
 +}
++
 +bool is_timestamp_expired(time_t timestamp, int max_age_seconds) {
 +    time_t now;
 +    time(&now);
 +    return (now - timestamp) > max_age_seconds;
 +}
++
 +/* Comparison utilities */
++
 +int compare_strings(const void *a, const void *b) {
 +    return strcmp(*(const char **)a, *(const char **)b);
 +}
++
 +int compare_accounts_by_id(const void *a, const void *b) {
 +    const account_t *acc_a = (const account_t *)a;
 +    const account_t *acc_b = (const account_t *)b;
++
 +    if (acc_a->id < acc_b->id) return -1;
 +    if (acc_a->id > acc_b->id) return 1;
 +    return 0;
 +}
++
 +int compare_accounts_by_name(const void *a, const void *b) {
 +    const account_t *acc_a = (const account_t *)a;
 +    const account_t *acc_b = (const account_t *)b;
++
 +    return strcmp(acc_a->name, acc_b->name);
 +}
++
 +/* Array utilities */
++
 +void sort_accounts(account_t *accounts, size_t count,
 +                   int (*compare)(const void *, const void *)) {
 +    if (accounts && count > 1 && compare) {
 +        qsort(accounts, count, sizeof(account_t), compare);
 +    }
 +}
++
 +account_t *find_account_in_array(account_t *accounts, size_t count,
 +                                 const char *identifier) {
 +    if (!accounts || !identifier || count == 0) {
 +        return NULL;
 +    }
++
 +    /* Try numeric ID first */
 +    char *endptr;
 +    unsigned long id = strtoul(identifier, &endptr, 10);
 +    if (*endptr == '\0') {
 +        /* It's a number - search by ID */
 +        for (size_t i = 0; i < count; i++) {
 +            if (accounts[i].id == (uint32_t)id) {
 +                return &accounts[i];
 +            }
 +        }
 +    }
++
 +    /* Search by name or description */
 +    for (size_t i = 0; i < count; i++) {
 +        if (strstr(accounts[i].name, identifier) ||
 +            strstr(accounts[i].description, identifier) ||
 +            strcmp(accounts[i].email, identifier) == 0) {
 +            return &accounts[i];
 +        }
 +    }
++
 +    return NULL;
 +}
++
 +/* Memory utilities */
++
 +void *safe_memset(void *ptr, int value, size_t size) {
 +    if (!ptr || size == 0) {
 +        set_error(ERR_INVALID_ARGS, "Invalid arguments to safe_memset");
 +        return NULL;
 +    }
++
 +    return memset(ptr, value, size);
 +}
++
 +void *safe_memcpy(void *dest, const void *src, size_t size) {
 +    if (!dest || !src || size == 0) {
 +        set_error(ERR_INVALID_ARGS, "Invalid arguments to safe_memcpy");
 +        return NULL;
 +    }
++
 +    return memcpy(dest, src, size);
 +}
++
 +int safe_mlock(void *ptr, size_t size) {
 +#if defined(__linux__)
 +    if (!ptr || size == 0) {
 +        set_error(ERR_INVALID_ARGS, "Invalid arguments to safe_mlock");
 +        return -1;
 +    }
++
 +    if (mlock(ptr, size) != 0) {
 +        set_system_error(ERR_SYSTEM_CALL, "Failed to lock memory");
 +        return -1;
 +    }
++
 +    return 0;
 +#else
 +    /* Not supported on this platform */
 +    (void)ptr;
 +    (void)size;
 +    return 0;
 +#endif
 +}
++
 +int safe_munlock(void *ptr, size_t size) {
 +#if defined(__linux__)
 +    if (!ptr || size == 0) {
 +        set_error(ERR_INVALID_ARGS, "Invalid arguments to safe_munlock");
 +        return -1;
 +    }
++
 +    if (munlock(ptr, size) != 0) {
 +        set_system_error(ERR_SYSTEM_CALL, "Failed to unlock memory");
 +        return -1;
 +    }
++
 +    return 0;
 +#else
 +    /* Not supported on this platform */
 +    (void)ptr;
 +    (void)size;
 +    return 0;
 +#endif
 +}
++
 +/* Cleanup utilities */
++
 +void cleanup_temporary_files(void) {
 +    /* Implementation would clean up any temporary files created */
 +    log_debug("Cleaning up temporary files");
 +}
++
 +int register_cleanup_handler(void (*handler)(void)) {
 +    if (!handler) {
 +        set_error(ERR_INVALID_ARGS, "NULL handler to register_cleanup_handler");
 +        return -1;
 +    }
++
 +    if (g_cleanup_handler_count >= sizeof(g_cleanup_handlers) / sizeof(g_cleanup_handlers[0])) {
 +        set_error(ERR_INVALID_ARGS, "Too many cleanup handlers registered");
 +        return -1;
 +    }
++
 +    g_cleanup_handlers[g_cleanup_handler_count++] = handler;
 +    return 0;
 +}
++
 +/* Debug utilities */
++
 +void dump_account(const account_t *account) {
 +    if (!account) {
 +        log_debug("Account: NULL");
 +        return;
 +    }
++
 +    log_debug("Account dump:");
 +    log_debug("  ID: %u", account->id);
 +    log_debug("  Name: %s", account->name);
 +    log_debug("  Email: %s", account->email);
 +    log_debug("  Description: %s", account->description);
 +    log_debug("  SSH enabled: %s", account->ssh_enabled ? "yes" : "no");
 +    log_debug("  SSH key: %s", account->ssh_key_path);
 +    log_debug("  GPG enabled: %s", account->gpg_enabled ? "yes" : "no");
 +    log_debug("  GPG signing: %s", account->gpg_signing_enabled ? "yes" : "no");
 +    log_debug("  GPG key: %s", account->gpg_key_id);
 +}
++
 +void dump_config(const config_t *config) {
 +    if (!config) {
 +        log_debug("Config: NULL");
 +        return;
 +    }
++
 +    log_debug("Config dump:");
 +    log_debug("  Default scope: %d", config->default_scope);
 +    log_debug("  Config path: %s", config->config_path);
 +    log_debug("  Verbose: %s", config->verbose ? "yes" : "no");
 +    log_debug("  Dry run: %s", config->dry_run ? "yes" : "no");
 +    log_debug("  Color output: %s", config->color_output ? "yes" : "no");
 +}
++
 +void dump_context(const gitswitch_ctx_t *ctx) {
 +    if (!ctx) {
 +        log_debug("Context: NULL");
 +        return;
 +    }
++
 +    log_debug("Context dump:");
 +    log_debug("  Account count: %zu", ctx->account_count);
 +    log_debug("  Current account: %s",
 +              ctx->current_account ? ctx->current_account->name : "none");
++
 +    dump_config(&ctx->config);
++
 +    for (size_t i = 0; i < ctx->account_count; i++) {
 +        dump_account(&ctx->accounts[i]);
 +    }
 +}