autodisplay-dispatcher.c

#define _GNU_SOURCE
#include <ctype.h>
#include <dirent.h>
#include <errno.h>
#include <pwd.h>
#include <stdarg.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <time.h>
#include <unistd.h>

#define MAX_PATH 4096
#define MAX_CMD 4096
#define MAX_DISPLAYS 16
#define STABILIZE_DELAY 4

typedef struct {
    char name[64];
    int connected;
} Display;

typedef struct {
    char name[64];
    int is_connected;
    int is_primary;
    int has_mode;
    char mode[64];
    int pos_x;
    int pos_y;
    char rotation[16];
} DisplayDetails;

static char config_dir[MAX_PATH];
static char home_dir[MAX_PATH];

typedef struct {
    FILE *handle;
    int is_process;
} XrandrStream;

static XrandrStream open_xrandr_stream(void);
static void close_xrandr_stream(XrandrStream *stream);

static void log_message(const char *fmt, ...);
static int safe_snprintf(char *dest, size_t size, const char *fmt, ...) __attribute__((format(printf, 3, 4)));

static int safe_snprintf(char *dest, size_t size, const char *fmt, ...) {
    va_list args;
    va_start(args, fmt);
    int written = vsnprintf(dest, size, fmt, args);
    va_end(args);

    if (written < 0 || (size_t)written >= size) {
        if (size > 0) {
            dest[size - 1] = '\0';
        }
        log_message("Path truncated for format '%s'", fmt);
        return -1;
    }
    return 0;
}

static void log_message(const char *fmt, ...) {
    char formatted[1024];
    va_list args;
    va_start(args, fmt);
    vsnprintf(formatted, sizeof(formatted), fmt, args);
    va_end(args);

    time_t now = time(NULL);
    char timestr[32];
    struct tm *tm_info = localtime(&now);
    if (tm_info) {
        strftime(timestr, sizeof(timestr), "%Y-%m-%d %H:%M:%S", tm_info);
    } else {
        strncpy(timestr, "unknown", sizeof(timestr) - 1);
        timestr[sizeof(timestr) - 1] = '\0';
    }

    char log_file[MAX_PATH];
    snprintf(log_file, sizeof(log_file), "/tmp/autodisplay.log");

    static int first_write = 1;
    FILE *f = fopen(log_file, first_write ? "w" : "a");
    first_write = 0;

    if (f) {
        fprintf(f, "[%s] %s\n", timestr, formatted);
        fclose(f);
    }

    printf("[%s] %s\n", timestr, formatted);
}

static void get_home_directory(void) {
    const char *override_home = getenv("AUTODISPLAY_STATE_HOME");
    if (override_home && override_home[0] != '\0') {
        strncpy(home_dir, override_home, sizeof(home_dir) - 1);
        home_dir[sizeof(home_dir) - 1] = '\0';
    } else {
        struct passwd *pw = getpwuid(getuid());
        if (!pw) {
            fprintf(stderr, "Failed to determine home directory\n");
            exit(EXIT_FAILURE);
        }
        strncpy(home_dir, pw->pw_dir, sizeof(home_dir) - 1);
        home_dir[sizeof(home_dir) - 1] = '\0';
    }

    if (safe_snprintf(config_dir, sizeof(config_dir), "%s/.config/autodisplay", home_dir) != 0) {
        fprintf(stderr, "Failed to construct config directory path\n");
        exit(EXIT_FAILURE);
    }
}

static int ensure_directory(const char *path, mode_t mode) {
    struct stat st;
    if (stat(path, &st) == 0) {
        if (S_ISDIR(st.st_mode)) {
            return 0;
        }
        errno = ENOTDIR;
        return -1;
    }

    if (mkdir(path, mode) == 0) {
        return 1;
    }

    if (errno == ENOENT) {
        char parent[MAX_PATH];
        strncpy(parent, path, sizeof(parent) - 1);
        parent[sizeof(parent) - 1] = '\0';
        char *slash = strrchr(parent, '/');
        if (slash) {
            *slash = '\0';
            if (ensure_directory(parent, mode) == -1) {
                return -1;
            }
        }
        if (mkdir(path, mode) == 0) {
            return 1;
        }
    }

    if (errno == EEXIST) {
        return 0;
    }

    return -1;
}

static void ensure_sample_script(const char *path, const char *header) {
    struct stat st;
    if (stat(path, &st) == 0) {
        return;
    }

    FILE *f = fopen(path, "w");
    if (!f) {
        log_message("Failed to create sample script %s: %s", path, strerror(errno));
        return;
    }

    fprintf(f, "#!/bin/bash\n");
    fprintf(f, "# %s\n", header);
    fprintf(f, "set -euo pipefail\n\n");
    fprintf(f, "LOGGER=${LOGGER:-logger}\n");
    fprintf(f, "${LOGGER} -t autodisplay '%s executed'\n", header);
    fclose(f);
    chmod(path, 0755);
}

static void setup_config_directories(void) {
    if (ensure_directory(config_dir, 0755) == -1) {
        log_message("Failed to create config directory %s: %s", config_dir, strerror(errno));
        exit(EXIT_FAILURE);
    }

    char state_dir[MAX_PATH];
    if (safe_snprintf(state_dir, sizeof(state_dir), "%s/state", config_dir) != 0) {
        log_message("Failed to build state directory path");
        exit(EXIT_FAILURE);
    }
    if (ensure_directory(state_dir, 0755) == -1) {
        log_message("Failed to create state directory %s: %s", state_dir, strerror(errno));
        exit(EXIT_FAILURE);
    }

    char default_dir[MAX_PATH];
    if (safe_snprintf(default_dir, sizeof(default_dir), "%s/default", config_dir) != 0) {
        log_message("Failed to build default directory path");
        exit(EXIT_FAILURE);
    }
    ensure_directory(default_dir, 0755);

    char pre_dir[MAX_PATH];
    if (safe_snprintf(pre_dir, sizeof(pre_dir), "%s/pre.d", default_dir) != 0) {
        log_message("Failed to build pre.d directory path");
        exit(EXIT_FAILURE);
    }
    ensure_directory(pre_dir, 0755);

    char post_dir[MAX_PATH];
    if (safe_snprintf(post_dir, sizeof(post_dir), "%s/post.d", default_dir) != 0) {
        log_message("Failed to build post.d directory path");
        exit(EXIT_FAILURE);
    }
    ensure_directory(post_dir, 0755);

    char pre_sample[MAX_PATH];
    if (safe_snprintf(pre_sample, sizeof(pre_sample), "%s/00-sample.sh", pre_dir) == 0) {
        ensure_sample_script(pre_sample, "Sample pre-display hook");
    }

    char post_sample[MAX_PATH];
    if (safe_snprintf(post_sample, sizeof(post_sample), "%s/00-sample.sh", post_dir) == 0) {
        ensure_sample_script(post_sample, "Sample post-display hook");
    }

    char default_xrandr[MAX_PATH];
    if (safe_snprintf(default_xrandr, sizeof(default_xrandr), "%s/xrandr", default_dir) != 0) {
        log_message("Failed to build default xrandr path");
        return;
    }
    struct stat st;
    if (stat(default_xrandr, &st) != 0) {
        FILE *f = fopen(default_xrandr, "w");
        if (f) {
            fprintf(f, "#!/bin/bash\n");
            fprintf(f, "# Default configuration - keep only the internal panel active\n");
            fprintf(f, "set -e\n\n");
            fprintf(f, "xrandr --output eDP --auto\n");
            fprintf(f, "xrandr | awk '/ connected/ && $1 !~ /^eDP/ {print $1}' | \\\n                    xargs -r -I {} xrandr --output {} --off\n");
            fclose(f);
            chmod(default_xrandr, 0755);
        }
    }
}

static int get_connected_displays(Display displays[], int max_displays) {
    XrandrStream stream = open_xrandr_stream();
    if (!stream.handle) {
        return 0;
    }

    char line[512];
    int count = 0;

    while (fgets(line, sizeof(line), stream.handle) && count < max_displays) {
        if (strstr(line, " connected") && !strstr(line, " disconnected")) {
            char token[64];
            if (sscanf(line, "%63s", token) == 1) {
                strncpy(displays[count].name, token, sizeof(displays[count].name) - 1);
                displays[count].name[sizeof(displays[count].name) - 1] = '\0';
                displays[count].connected = 1;
                log_message("Found connected display: %s", displays[count].name);
                count++;
            }
        }
    }

    close_xrandr_stream(&stream);
    log_message("Total displays found: %d", count);
    return count;
}

static int is_internal_display(const char *name) {
    return strncmp(name, "eDP", 3) == 0 || strncmp(name, "LVDS", 4) == 0;
}

static int compare_names(const void *a, const void *b) {
    const char *sa = *(const char *const *)a;
    const char *sb = *(const char *const *)b;
    return strcmp(sa, sb);
}

static void create_display_signature(Display displays[], int count, char *signature, size_t max_len) {
    const char *names[MAX_DISPLAYS];
    int external_count = 0;

    for (int i = 0; i < count; i++) {
        if (displays[i].connected && !is_internal_display(displays[i].name)) {
            names[external_count++] = displays[i].name;
        }
    }

    if (external_count == 0) {
        snprintf(signature, max_len, "default");
        return;
    }

    qsort(names, external_count, sizeof(char *), compare_names);

    signature[0] = '\0';
    for (int i = 0; i < external_count; i++) {
        if (i > 0) {
            strncat(signature, "_", max_len - strlen(signature) - 1);
        }
        strncat(signature, names[i], max_len - strlen(signature) - 1);
    }
}

static int read_last_signature(char *buffer, size_t len) {
    char state_path[MAX_PATH];
    if (safe_snprintf(state_path, sizeof(state_path), "%s/state/last_signature", config_dir) != 0) {
        log_message("Failed to build state file path");
        return 0;
    }

    FILE *f = fopen(state_path, "r");
    if (!f) {
        return 0;
    }

    if (!fgets(buffer, len, f)) {
        fclose(f);
        return 0;
    }

    buffer[strcspn(buffer, "\r\n")] = '\0';
    fclose(f);
    return 1;
}

static void write_last_signature(const char *signature) {
    char state_path[MAX_PATH];
    if (safe_snprintf(state_path, sizeof(state_path), "%s/state/last_signature", config_dir) != 0) {
        log_message("Failed to build state file path");
        return;
    }

    FILE *f = fopen(state_path, "w");
    if (!f) {
        log_message("Failed to persist last signature: %s", strerror(errno));
        return;
    }
    fprintf(f, "%s\n", signature);
    fclose(f);
}

static int script_cmp(const void *a, const void *b) {
    const char *const *sa = a;
    const char *const *sb = b;
    return strcmp(*sa, *sb);
}

static void run_scripts_in_directory(const char *dir_path) {
    DIR *dir = opendir(dir_path);
    if (!dir) {
        return;
    }

    char scripts_storage[128][MAX_PATH];
    const char *scripts[128];
    int script_count = 0;
    struct dirent *entry;

    while ((entry = readdir(dir)) != NULL && script_count < 128) {
        if (entry->d_name[0] == '.') {
            continue;
        }

        char script_path[MAX_PATH];
        if (safe_snprintf(script_path, sizeof(script_path), "%s/%s", dir_path, entry->d_name) != 0) {
            log_message("Skipping script with overly long path in %s", dir_path);
            continue;
        }

        struct stat st;
        if (stat(script_path, &st) == 0 && S_ISREG(st.st_mode) && (st.st_mode & S_IXUSR)) {
            snprintf(scripts_storage[script_count], sizeof(scripts_storage[script_count]), "%s", script_path);
            scripts[script_count] = scripts_storage[script_count];
            script_count++;
        }
    }
    closedir(dir);

    qsort(scripts, script_count, sizeof(char *), script_cmp);

    for (int i = 0; i < script_count; i++) {
        log_message("Executing: %s", scripts[i]);
        int status = system(scripts[i]);
        if (status != 0) {
            log_message("Script failed with status %d: %s", status, scripts[i]);
        }
    }
}

static XrandrStream open_xrandr_stream(void) {
    XrandrStream stream = {0};
    const char *fixture = getenv("AUTODISPLAY_XRANDR_FIXTURE");
    if (fixture && fixture[0] != '\0') {
        stream.handle = fopen(fixture, "r");
        if (!stream.handle) {
            log_message("Failed to open fixture %s: %s", fixture, strerror(errno));
        }
        return stream;
    }

    FILE *proc = popen("xrandr --query", "r");
    if (!proc) {
        log_message("ERROR: Failed to run xrandr: %s", strerror(errno));
        return stream;
    }

    stream.handle = proc;
    stream.is_process = 1;
    return stream;
}

static void close_xrandr_stream(XrandrStream *stream) {
    if (!stream || !stream->handle) {
        return;
    }
    if (stream->is_process) {
        pclose(stream->handle);
    } else {
        fclose(stream->handle);
    }
    stream->handle = NULL;
    stream->is_process = 0;
}

static void execute_display_config(const char *config_name) {
    char config_path[MAX_PATH];
    char pre_path[MAX_PATH];
    char post_path[MAX_PATH];
    char xrandr_path[MAX_PATH];

    if (safe_snprintf(config_path, sizeof(config_path), "%s/%s", config_dir, config_name) != 0) {
        log_message("Configuration path too long for %s", config_name);
        return;
    }
    if (safe_snprintf(pre_path, sizeof(pre_path), "%s/pre.d", config_path) != 0) {
        log_message("pre.d path too long for %s", config_name);
        return;
    }
    if (safe_snprintf(post_path, sizeof(post_path), "%s/post.d", config_path) != 0) {
        log_message("post.d path too long for %s", config_name);
        return;
    }
    if (safe_snprintf(xrandr_path, sizeof(xrandr_path), "%s/xrandr", config_path) != 0) {
        log_message("xrandr path too long for %s", config_name);
        return;
    }

    log_message("Executing config: %s", config_name);

    run_scripts_in_directory(pre_path);

    log_message("Waiting for displays to stabilize...");
    sleep(STABILIZE_DELAY);

    struct stat st;
    if (stat(xrandr_path, &st) == 0 && (st.st_mode & S_IXUSR)) {
        log_message("Executing xrandr config: %s", xrandr_path);
        char cmd[MAX_CMD];
        if (safe_snprintf(cmd, sizeof(cmd), "cd %s && ./xrandr", config_path) != 0) {
            log_message("xrandr command too long for %s", config_name);
            return;
        }
        int status = system(cmd);
        if (status != 0) {
            log_message("xrandr config failed with status %d", status);
        }
    } else {
        log_message("No xrandr config found or not executable for %s", config_name);
    }

    run_scripts_in_directory(post_path);
}

static int validate_config_name(const char *name) {
    if (!name || !*name) {
        return 0;
    }
    if (strstr(name, "..")) {
        return 0;
    }
    for (const char *c = name; *c; ++c) {
        if (!(isalnum((unsigned char)*c) || *c == '-' || *c == '_' || *c == '.')) {
            return 0;
        }
    }
    return 1;
}

static void sanitize_rotation(DisplayDetails *detail) {
    if (detail->rotation[0] == '\0') {
        strncpy(detail->rotation, "normal", sizeof(detail->rotation) - 1);
        detail->rotation[sizeof(detail->rotation) - 1] = '\0';
    }
}

static int collect_display_details(DisplayDetails details[], int max_details, char disconnected[][64], int *disconnected_count) {
    XrandrStream stream = open_xrandr_stream();
    if (!stream.handle) {
        return -1;
    }

    char line[512];
    int count = 0;
    int disc_count = 0;

    while (fgets(line, sizeof(line), stream.handle)) {
        char name[64];
        if (sscanf(line, "%63s", name) != 1) {
            continue;
        }

        if (strstr(line, " connected")) {
            if (count >= max_details) {
                continue;
            }
            DisplayDetails *d = &details[count];
            memset(d, 0, sizeof(DisplayDetails));
            snprintf(d->name, sizeof(d->name), "%s", name);
            d->is_connected = 1;

            char *connected_ptr = strstr(line, " connected");
            char *cursor = connected_ptr ? connected_ptr + strlen(" connected") : NULL;
            if (cursor) {
                while (*cursor == ' ') {
                    cursor++;
                }
                if (strncmp(cursor, "primary", 7) == 0 && (cursor[7] == ' ' || cursor[7] == '\0')) {
                    d->is_primary = 1;
                    cursor += 7;
                    while (*cursor == ' ') {
                        cursor++;
                    }
                }

                char token[128];
                if (sscanf(cursor, "%127s", token) == 1) {
                    char token_copy[128];
                    strncpy(token_copy, token, sizeof(token_copy) - 1);
                    token_copy[sizeof(token_copy) - 1] = '\0';
                    char *plus = strchr(token_copy, '+');
                    if (plus) {
                        *plus = '\0';
                        char *plus2 = strchr(plus + 1, '+');
                        if (plus2) {
                            *plus2 = '\0';
                            d->has_mode = 1;
                            strncpy(d->mode, token_copy, sizeof(d->mode) - 1);
                            d->mode[sizeof(d->mode) - 1] = '\0';
                            d->pos_x = atoi(plus + 1);
                            d->pos_y = atoi(plus2 + 1);
                        }
                    }
                }

                char *paren = strchr(line, '(');
                if (paren) {
                    char rotation[16];
                    if (sscanf(paren + 1, "%15s", rotation) == 1) {
                        rotation[strcspn(rotation, ") ")] = '\0';
                        strncpy(d->rotation, rotation, sizeof(d->rotation) - 1);
                        d->rotation[sizeof(d->rotation) - 1] = '\0';
                    }
                }
            }

            sanitize_rotation(d);
            count++;
        } else if (strstr(line, " disconnected")) {
            if (disc_count < max_details) {
                snprintf(disconnected[disc_count], sizeof(disconnected[disc_count]), "%s", name);
                disc_count++;
            }
        }
    }

    close_xrandr_stream(&stream);

    if (disconnected_count) {
        *disconnected_count = disc_count;
    }

    return count;
}

static int save_current_configuration(const char *name) {
    if (!validate_config_name(name)) {
        log_message("Invalid configuration name: %s", name ? name : "(null)");
        return -1;
    }

    DisplayDetails details[MAX_DISPLAYS];
    char disconnected[MAX_DISPLAYS][64];
    int disconnected_count = 0;
    int count = collect_display_details(details, MAX_DISPLAYS, disconnected, &disconnected_count);
    if (count < 0) {
        return -1;
    }
    if (count == 0) {
        log_message("No active displays detected; cannot save configuration");
        return -1;
    }

    char config_path[MAX_PATH];
    if (safe_snprintf(config_path, sizeof(config_path), "%s/%s", config_dir, name) != 0) {
        log_message("Configuration path too long for %s", name);
        return -1;
    }
    ensure_directory(config_path, 0755);

    char pre_dir[MAX_PATH];
    if (safe_snprintf(pre_dir, sizeof(pre_dir), "%s/pre.d", config_path) != 0) {
        log_message("pre.d path too long for %s", name);
        return -1;
    }
    ensure_directory(pre_dir, 0755);

    char post_dir[MAX_PATH];
    if (safe_snprintf(post_dir, sizeof(post_dir), "%s/post.d", config_path) != 0) {
        log_message("post.d path too long for %s", name);
        return -1;
    }
    ensure_directory(post_dir, 0755);

    char pre_sample[MAX_PATH];
    if (safe_snprintf(pre_sample, sizeof(pre_sample), "%s/00-sample.sh", pre_dir) == 0) {
        ensure_sample_script(pre_sample, "Sample pre-display hook");
    }

    char post_sample[MAX_PATH];
    if (safe_snprintf(post_sample, sizeof(post_sample), "%s/00-sample.sh", post_dir) == 0) {
        ensure_sample_script(post_sample, "Sample post-display hook");
    }

    char xrandr_path[MAX_PATH];
    if (safe_snprintf(xrandr_path, sizeof(xrandr_path), "%s/xrandr", config_path) != 0) {
        log_message("xrandr path too long for %s", name);
        return -1;
    }

    FILE *f = fopen(xrandr_path, "w");
    if (!f) {
        log_message("Failed to write configuration script %s: %s", xrandr_path, strerror(errno));
        return -1;
    }

    time_t now = time(NULL);
    struct tm *tm_info = localtime(&now);
    char timestamp[64] = "unknown";
    if (tm_info) {
        strftime(timestamp, sizeof(timestamp), "%Y-%m-%d %H:%M:%S", tm_info);
    }

    fprintf(f, "#!/bin/bash\n");
    fprintf(f, "# Auto-generated by autodisplay-dispatcher --save %s on %s\n", name, timestamp);
    fprintf(f, "set -euo pipefail\n\n");

    int total_entries = count + disconnected_count;
    if (total_entries == 0) {
        fprintf(f, "xrandr --auto\n");
    } else {
        fprintf(f, "xrandr \\\n");
        int emitted = 0;
        for (int i = 0; i < count; i++) {
            DisplayDetails *d = &details[i];
            sanitize_rotation(d);
            fprintf(f, "    --output %s", d->name);
            if (d->is_primary) {
                fprintf(f, " --primary");
            }
            if (d->has_mode) {
                fprintf(f, " --mode %s", d->mode);
            } else {
                fprintf(f, " --auto");
            }
            fprintf(f, " --pos %dx%d --rotate %s", d->pos_x, d->pos_y, d->rotation);
            emitted++;
            fprintf(f, emitted < total_entries ? " \\\n" : "\n");
        }
        for (int i = 0; i < disconnected_count; i++) {
            fprintf(f, "    --output %s --off", disconnected[i]);
            emitted++;
            fprintf(f, emitted < total_entries ? " \\\n" : "\n");
        }
    }

    fclose(f);
    chmod(xrandr_path, 0755);

    log_message("Saved current configuration as '%s'", name);
    return 0;
}

static void print_usage(const char *progname) {
    fprintf(stderr,
            "Usage: %s [--apply] [--force] | --save <name> | --print-signature\n"
            "  --apply            Apply configuration for current display state (default).\n"
            "  --force            Apply even if the detected state matches the last applied state.\n"
            "  --save <name>      Capture the current xrandr layout into a named configuration.\n"
            "  --print-signature  Output the current display signature and exit.\n",
            progname);
}

int main(int argc, char *argv[]) {
    get_home_directory();
    setup_config_directories();

    const char *display_env = getenv("DISPLAY");
    if (!display_env || display_env[0] == '\0') {
        setenv("DISPLAY", ":0", 1);
    }
    char xauth_path[MAX_PATH];
    if (safe_snprintf(xauth_path, sizeof(xauth_path), "%s/.Xauthority", home_dir) == 0) {
        const char *xauth_env = getenv("XAUTHORITY");
        if (!xauth_env || xauth_env[0] == '\0') {
            setenv("XAUTHORITY", xauth_path, 1);
        }
    }

    bool force = false;
    enum { MODE_APPLY, MODE_SAVE, MODE_PRINT } mode = MODE_APPLY;
    const char *save_name = NULL;

    for (int i = 1; i < argc; i++) {
        if (strcmp(argv[i], "--force") == 0) {
            force = true;
        } else if (strcmp(argv[i], "--apply") == 0) {
            mode = MODE_APPLY;
        } else if (strcmp(argv[i], "--save") == 0) {
            if (i + 1 >= argc) {
                print_usage(argv[0]);
                return EXIT_FAILURE;
            }
            save_name = argv[++i];
            mode = MODE_SAVE;
        } else if (strcmp(argv[i], "--print-signature") == 0) {
            mode = MODE_PRINT;
        } else {
            print_usage(argv[0]);
            return EXIT_FAILURE;
        }
    }

    if (mode == MODE_SAVE) {
        return save_current_configuration(save_name) == 0 ? EXIT_SUCCESS : EXIT_FAILURE;
    }

    Display displays[MAX_DISPLAYS];
    memset(displays, 0, sizeof(displays));
    int display_count = get_connected_displays(displays, MAX_DISPLAYS);

    if (display_count == 0) {
        log_message("No displays detected, exiting");
        return EXIT_FAILURE;
    }

    char signature[128];
    create_display_signature(displays, display_count, signature, sizeof(signature));

    if (mode == MODE_PRINT) {
        printf("%s\n", signature);
        return EXIT_SUCCESS;
    }

    char last_signature[128];
    int has_last = read_last_signature(last_signature, sizeof(last_signature));

    if (!force && has_last && strcmp(last_signature, signature) == 0) {
        log_message("Display state '%s' already applied; skipping", signature);
        return EXIT_SUCCESS;
    }

    int external_count = 0;
    int has_internal = 0;
    for (int i = 0; i < display_count; i++) {
        if (displays[i].connected) {
            if (is_internal_display(displays[i].name)) {
                has_internal = 1;
            } else {
                external_count++;
            }
        }
    }

    int transitioning_to_default = strcmp(signature, "default") == 0 && (!has_last || strcmp(last_signature, "default") != 0);
    if (transitioning_to_default && has_internal) {
        log_message("Transitioning to default; running xrandr --auto guard");
        int auto_status = system("xrandr --auto");
        if (auto_status != 0) {
            log_message("xrandr --auto guard failed with status %d", auto_status);
        }
        sleep(STABILIZE_DELAY);
    }

    if (external_count == 0 && has_internal && !transitioning_to_default) {
        log_message("Only internal display detected - ensuring xrandr auto configuration");
        int auto_status = system("xrandr --auto");
        if (auto_status != 0) {
            log_message("xrandr --auto fallback failed with status %d", auto_status);
        }
        sleep(STABILIZE_DELAY);
    }

    log_message("Display signature: %s (external displays: %d)", signature, external_count);

    char config_path[MAX_PATH];
    if (safe_snprintf(config_path, sizeof(config_path), "%s/%s", config_dir, signature) != 0) {
        log_message("Configuration path too long for signature %s", signature);
        return EXIT_FAILURE;
    }
    struct stat st;
    const char *target_config = NULL;

    if (stat(config_path, &st) == 0 && S_ISDIR(st.st_mode)) {
        target_config = signature;
    } else {
        log_message("No specific config found for %s, using default", signature);
        target_config = "default";
    }

    execute_display_config(target_config);
    write_last_signature(signature);

    log_message("AutoDisplay dispatcher completed");
    return EXIT_SUCCESS;
}