/* meow_svcd.c — MeowOS 服务管理器守护进程（类 systemd/systemctl 角色）。
 *
 * 定位（用户定案，见 docs/MEOWOS_SPEC_REF §1.2 / DEV_NOTES）：
 *   - 独立于 supervisor（meow_bootmenu/launcher）的进程，但由 supervisor 托管
 *     fork/exec 启动；
 *   - 每个「服务」也是一个独立子进程（fork+exec），由本进程 waitpid 收 SIGCHLD，
 *     实现严重崩溃隔离：服务崩绝不拖垮 svcd，也绝不连带 supervisor；
 *   - svcd 本身极简：无 dlopen、无外部依赖，仅依赖 POSIX + Linux 基础接口，
 *     交叉编译为 mipsel 静态（zig-mipsel-cc），打进固件（不入卡）。
 *
 * 配置来源（双源，目录式；板载优先）：
 *   - 板载  `/usr/data/meow/services.d/<name>.conf`（Data 区，恒定存在，权威源）；
 *   - TF 卡 `$CARD/MeowOS/services.d/<name>.conf`（默认 `CARD=/usr/data/mnt/sd_0`）。
 *   扫描**两处都读**；同名服务**板载优先**（扫 TF 时若 name 已在板载 → 跳过 + WARN
 *   「<name> 板载与 TF 都存在，采用板载」）。无双源冲突时行为不变。
 *   卡拔出 → svcd 优雅停止所托管**卡上**服务并保留运行状态（板载服务视 trigger 保留）；
 *   插卡 → 自动重建。
 *
 * .conf 字段（极简 key = value，'#'/';' 注释，见 meow_svcd.md 文档）：
 *   name / exec / args / env / enabled / restart / backoff_ms / max_restart /
 *   cap / trigger。字段含义与状态机见文件尾部注释块 + meow_svcd.md。
 *
 * 事件触发（低成本轮询，避免复杂订阅）：
 *   - 卡挂载：轮询 `$CARD/MeowOS/services.d` 存在性（每 SVCD_SCAN_MS 扫一次）；
 *   - WiFi 状态：可选，读 /sys/class/net/<iface>/operstate 判定（wifi-up 触发用，
 *     本平台无 WiFi 接口时恒为 0，属扩展点）；
 *   - boot：配置在卡 → 随卡存在即启动（拔卡即停）。
 *
 * 控制通道：AF_UNIX 单行文本协议（默认 /tmp/meow_svcd.sock）：
 *   start|stop|restart <name|all> / status / reload / pid
 *   后台常驻模式默认（无子命令即启动守护进程）；`-f/--foreground` 供 supervisor
 *   fork/exec 托管（保证 supervisor 可 waitpid）。
 *
 * 状态文件：`/tmp/meow_svcd.status`（可 --status 覆盖），状态变更+周期落盘，
 *   板载 tmpfs 存活期内可读。
 *
 * 日志：svcd 自身日志走 stderr（便于 supervisor 捕获）；可选 MEOW_SVCD_LOG 追加
 *   文件。服务子进程继承 svcd 的 stdio（其 stdout/stderr 落到同一 sink），无需
 *   dlopen/管道，天然规避服务输出撑爆 svcd 内存导致的崩溃。
 *
 * 编译（mipsel 静态，见 build_svcd.sh）：
 *   ~/Project/R3ProII/.tools/zig-mipsel-cc -Os -Wall -Wextra -static meow_svcd.c -o meow_svcd
 * 宿主编译（集成测试）：gcc -Os -Wall -Wextra meow_svcd.c -o meow_svcd_host
 */
#define _GNU_SOURCE

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdarg.h>
#include <stdint.h>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>
#include <signal.h>
#include <time.h>
#include <dirent.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <poll.h>

/* ---- 默认路径 / 常量 ---- */
#define SVCD_CARD_DEFAULT   "/usr/data/mnt/sd_0"      /* TF 卡挂载点（SPEC §1.2） */
#define SVCD_SERVICES_REL   "MeowOS/services.d"        /* TF 配置目录（用户定案目录式） */
#define SVCD_SERVICES_BOARD "/usr/data/meow/services.d" /* 板载配置目录（首启预置/Data 区） */
#define SVCD_PATH_MAX       256                        /* 服务源目录路径缓冲上限 */
#define SVCD_SOCK_DEFAULT   "/tmp/meow_svcd.sock"
#define SVCD_STATUS_DEFAULT "/tmp/meow_svcd.status"
#define SVCD_PIDFILE_DEFAULT "/tmp/meow_svcd.pid"

#define SVCD_MAX_SERVICES 64
#define SVCD_NAME_MAX   64
#define SVCD_EXEC_MAX   256
#define SVCD_LINE_MAX   1024     /* .conf / 命令单行上限 */
#define SVCD_ARG_MAX    128      /* 单参数串上限 */
#define SVCD_MAX_ARGS   24       /* args 个数上限 */
#define SVCD_ENV_MAX    24       /* env 条数上限 */
#define SVCD_ENV_MAXLEN 128      /* 单条 env "K=V" 上限 */
#define SVCD_CAP_MAX    128
#define SVCD_RESTART_STR_MAX 16
#define SVCD_TRIG_STR_MAX   16

#define SVCD_SCAN_MS      1000   /* 卡/wifi 轮询间隔 */
#define SVCD_TICK_MAX_MS  500    /* poll 上限（卡变化 ~1s 内感知） */
#define SVCD_STOP_GRACE_MS 2500  /* SIGTERM 后 SIGKILL 兜底 */
#define SVCD_STABLE_MS    30000  /* 连续运行此毫秒 → 重置 restart_count */
#define SVCD_SOCK_PATH_MAX 108
#define SVCD_SIGCHLD_CHAR 'C'    /* 自管道字节（拉起 poll） */
#define SVCD_SIGTERM_CHAR 'T'

/* ---- 服务状态机 ---- */
typedef enum {
    SV_DISABLED = 0,   /* enabled=0，永不自动启动 */
    SV_STOPPED,        /* 未运行（因触发不满足/被停/等待退避） */
    SV_RUNNING,        /* 子进程存活 */
    SV_STOPPING,       /* 已发 SIGTERM，等退出（超时 SIGKILL 兜底） */
    SV_FAILED          /* 崩溃且不再重启（超 max_restart/restart=never） */
} sv_state_t;

static const char *g_state_str[] = { "disabled", "stopped", "running",
                                     "stopping", "failed" };

typedef struct {
    char name[SVCD_NAME_MAX];
    char exec[SVCD_EXEC_MAX];
    char argbuf[SVCD_MAX_ARGS][SVCD_ARG_MAX];   /* args 拷贝 */
    char *argv[SVCD_MAX_ARGS + 1];              /* exec + args，末尾 NULL */
    int  argc;
    char envbuf[SVCD_ENV_MAX][SVCD_ENV_MAXLEN]; /* "K=V" */
    int  envc;
    int  enabled;
    char restart[SVCD_RESTART_STR_MAX];         /* always|on-fail|never */
    long backoff_ms;
    int  max_restart;                           /* <0=无限 */
    char cap[SVCD_CAP_MAX];                     /* 解析保留；实装为后续任务 */
    char trigger[SVCD_TRIG_STR_MAX];            /* boot|card-mount|wifi-up */
    int  src;                                   /* 0=TF 卡, 1=板载（同名优先源） */

    /* 运行状态 */
    pid_t      pid;
    sv_state_t state;
    int        restart_count;
    int        last_exit_status;                /* waitpid status */
    unsigned long long restart_at_ms;           /* 退避到期时间；0=无到期 */
    unsigned long long stop_since_ms;           /* SIGTERM 发出时刻 */
    unsigned long long run_since_ms;            /* 本轮启动时刻 */
    int        stop_requested;                  /* 正在被停（勿按崩溃策略重启） */
    int        restart_pending;                 /* 停后需重启（restart 命令） */
    int        user_stopped;                    /* 用户 stop，勿按触发自动拉起 */
    int        in_config;                       /* 本次扫描仍存在 */
} svc_t;

static svc_t g_svcs[SVCD_MAX_SERVICES];
static int   g_nsvc = 0;

/* 全局环境（可被 --card/--sock/--status 覆盖，亦读 env） */
static char g_card[256]   = SVCD_CARD_DEFAULT;
static char g_board_dir[256] = SVCD_SERVICES_BOARD; /* 板载服务目录（--board/MEOW_SVCD_BOARD 可覆写） */
static char g_sock[SVCD_SOCK_PATH_MAX] = SVCD_SOCK_DEFAULT;
static char g_status[256]  = SVCD_STATUS_DEFAULT;
static char g_pidfile[256] = SVCD_PIDFILE_DEFAULT;
static char g_log[256]     = "";                 /* 可选日志文件 */

static int    g_card_present = 0;
static int    g_board_online = 0;               /* 板载服务目录本帧可读 */
static int    g_wifi_up      = 0;
static int    g_shutdown     = 0;
static int    g_fg           = 0;                /* -f：前台（supervisor 托管） */
static int    g_sigpipe[2]   = {-1, -1};         /* 信号自管道 */
static int    g_listen_fd    = -1;               /* 控制 socket */
static int    g_status_fd    = -1;               /* 状态文件 fd（-1=未开） */

static void handle_connection(int fd);

static unsigned long long now_ms(void)
{
    struct timespec ts;
    clock_gettime(CLOCK_MONOTONIC, &ts);
    return (unsigned long long)ts.tv_sec * 1000 + (unsigned long long)ts.tv_nsec / 1000000;
}

/* ---- log：svcd 自身日志走 stderr（supervisor 捕获），可选追加文件 ---- */
static void svcd_log(const char *fmt, ...)
{
    char buf[512], line[560];
    va_list ap;
    va_start(ap, fmt);
    vsnprintf(buf, sizeof buf, fmt, ap);
    va_end(ap);
    int l = snprintf(line, sizeof line, "%llu [meow_svcd] %s\n",
                     now_ms(), buf);
    fprintf(stderr, "%s", line);
    fflush(stderr);
    if (g_log[0]) {
        int fd = open(g_log, O_WRONLY | O_APPEND | O_CREAT, 0644);
        if (fd >= 0) { ssize_t w = write(fd, line, (size_t)l); (void)w; close(fd); }
    }
}

/* ---- 简单工具 ---- */
static int safe_strcpy(char *dst, size_t cap, const char *src)
{
    if (!dst || cap == 0) return -1;
    int n = snprintf(dst, cap, "%s", src ? src : "");
    return (n >= 0 && (size_t)n < cap) ? 0 : -1;
}

static char *trim(char *s)
{
    char *end;
    while (*s == ' ' || *s == '\t' || *s == '\r' || *s == '\n') s++;
    if (*s == '\0') return s;
    end = s + strlen(s) - 1;
    while (end > s && (*end == ' ' || *end == '\t' || *end == '\r' || *end == '\n')) *end-- = '\0';
    return s;
}

/* 让 fd 在 exec 后自动关闭：服务子进程 fork+exec 后绝不继承守护进程的
 * 监听 socket / 已接受连接 / 自管道 / 状态文件 fd —— 否则子进程一直持有
 * 客户端连接副本，客户端读不到 EOF 而阻塞；监听 socket 也被子进程占着。 */
static void set_cloexec(int fd)
{
    if (fd < 0) return;
    int fl = fcntl(fd, F_GETFD, 0);
    if (fl >= 0) fcntl(fd, F_SETFD, fl | FD_CLOEXEC);
}

static long read_file(const char *path, char *buf, size_t sz)
{
    int fd = open(path, O_RDONLY);
    if (fd < 0) return -1;
    ssize_t n = read(fd, buf, sz - 1);
    close(fd);
    if (n < 0) return -1;
    buf[n] = '\0';
    return (long)n;
}

static int write_file(const char *path, const char *data, size_t len)
{
    int fd = open(path, O_WRONLY | O_CREAT | O_TRUNC, 0644);
    if (fd < 0) return -1;
    ssize_t n = write(fd, data, len);
    close(fd);
    return (n == (ssize_t)len) ? 0 : -1;
}

/* ---- 配置解析 ---- */

/* 极简 tokenizer：按空白切分，支持单/双引号与反斜杠转义。int。 */
static int split_args(char *in, char tok[][SVCD_ARG_MAX], int maxtok)
{
    int n = 0;
    char *p = in;
    while (*p && n < maxtok) {
        while (*p == ' ' || *p == '\t') p++;
        if (!*p) break;
        char *out = tok[n];
        int oi = 0;
        char quote = 0;
        while (*p) {
            char c = *p;
            if (quote) {
                if (c == quote) { quote = 0; p++; continue; }
                if (c == '\\' && p[1]) { p++; c = *p; }
            } else {
                if (c == ' ' || c == '\t') break;
                if (c == '"' || c == '\'') { quote = c; p++; continue; }
                if (c == '\\' && p[1]) { p++; c = *p; }
            }
            if (oi < SVCD_ARG_MAX - 1) out[oi++] = c;
            p++;
        }
        out[oi] = '\0';
        if (oi > 0) n++;
    }
    return n;
}

static void apply_field(svc_t *s, const char *k, const char *v)
{
    if      (strcmp(k, "exec") == 0)       { safe_strcpy(s->exec, sizeof s->exec, v); }
    else if (strcmp(k, "args") == 0)       { s->argc = split_args((char *)v, s->argbuf, SVCD_MAX_ARGS); }
    else if (strcmp(k, "env") == 0)        {
        if (s->envc < SVCD_ENV_MAX)
            safe_strcpy(s->envbuf[s->envc++], sizeof s->envbuf[0], v);
    }
    else if (strcmp(k, "enabled") == 0)    { s->enabled = (atoi(v) != 0); }
    else if (strcmp(k, "restart") == 0)    { safe_strcpy(s->restart, sizeof s->restart, v); }
    else if (strcmp(k, "backoff_ms") == 0) { s->backoff_ms = atol(v); }
    else if (strcmp(k, "max_restart") == 0){ s->max_restart = atoi(v); }
    else if (strcmp(k, "cap") == 0)        { safe_strcpy(s->cap, sizeof s->cap, v); }
    else if (strcmp(k, "trigger") == 0)    { safe_strcpy(s->trigger, sizeof s->trigger, v); }
    else if (strcmp(k, "name") == 0)       { /* 名字以文件名为准，name 仅备忘 */ }
    /* 未知键忽略（前向兼容） */
}

/* 解析单个 .conf 到 svc（name=basename）。成功返回 0。 */
static int load_conf(const char *path, const char *name, svc_t *s)
{
    char buf[SVCD_LINE_MAX];
    FILE *f = fopen(path, "r");
    if (!f) return -1;

    memset(s, 0, sizeof *s);
    safe_strcpy(s->name, sizeof s->name, name);
    s->enabled = 0;                 /* 默认禁用（显式 enabled=1 才启动） */
    s->state   = SV_STOPPED;
    safe_strcpy(s->restart, sizeof s->restart, "on-fail");   /* 默认策略 */
    s->backoff_ms  = 1000;
    s->max_restart = 5;
    safe_strcpy(s->trigger, sizeof s->trigger, "card-mount"); /* 默认触发 */

    while (fgets(buf, sizeof buf, f)) {
        char *line = trim(buf);
        if (!*line || *line == '#' || *line == ';') continue;
        char *eq = strchr(line, '=');
        if (!eq) continue;
        *eq = '\0';
        char *k = trim(line);
        char *v = trim(eq + 1);
        for (char *q = v; *q; q++) {
            if ((*q == '#' || *q == ';') && (q == v || *(q - 1) != '\\')) { *q = '\0'; break; }
        }
        v = trim(v);
        if (k[0]) apply_field(s, k, v);
    }
    fclose(f);

    if (!s->exec[0]) { svcd_log("service %s: no exec, skip", name); return -1; }
    if (s->backoff_ms < 0) s->backoff_ms = 0;
    if (s->max_restart < 0) s->max_restart = -1;   /* 无限 */
    if (strcmp(s->restart, "always") && strcmp(s->restart, "on-fail") &&
        strcmp(s->restart, "never"))
        safe_strcpy(s->restart, sizeof s->restart, "on-fail");
    if (strcmp(s->trigger, "boot") && strcmp(s->trigger, "card-mount") &&
        strcmp(s->trigger, "wifi-up"))
        safe_strcpy(s->trigger, sizeof s->trigger, "card-mount");

    /* argv[0]=exec；随后 args */
    s->argv[0] = s->exec;
    for (int i = 0; i < s->argc; i++) s->argv[i + 1] = s->argbuf[i];
    s->argv[s->argc + 1] = NULL;

    return 0;
}

/* ---- 服务表工具 ---- */
static int find_svc(const char *name)
{
    for (int i = 0; i < g_nsvc; i++)
        if (strcmp(g_svcs[i].name, name) == 0) return i;
    return -1;
}

static void remove_svc_idx(int idx)
{
    if (idx < 0 || idx >= g_nsvc) return;
    if (g_nsvc - idx - 1 > 0)
        memmove(&g_svcs[idx], &g_svcs[idx + 1],
                (size_t)(g_nsvc - idx - 1) * sizeof(svc_t));
    g_nsvc--;
}

static void build_status_file(void)
{
    char buf[8192];
    int n = snprintf(buf, sizeof buf,
        "# meow_svcd status\ncard_present=%d\nwifi_up=%d\nservices=%d\n",
        g_card_present, g_wifi_up, g_nsvc);
    for (int i = 0; i < g_nsvc && n < (int)sizeof buf - 1; i++) {
        svc_t *s = &g_svcs[i];
        int k = snprintf(buf + n, sizeof buf - (size_t)n,
            "svc=%s state=%s pid=%d restart=%d exit=%d trigger=%s backoff_ms=%ld\n",
            s->name, g_state_str[s->state], (int)s->pid, s->restart_count,
            s->last_exit_status, s->trigger, s->backoff_ms);
        if (k <= 0) break;
        n += k;
    }
    if (g_status_fd >= 0) {
        if (lseek(g_status_fd, 0, SEEK_SET) == 0 && ftruncate(g_status_fd, 0) == 0) {
            ssize_t w = write(g_status_fd, buf, (size_t)n);
            (void)w;
        }
    } else {
        (void)write_file(g_status, buf, (size_t)n);
    }
}

/* ---- 子进程管理 ---- */

/* 实际拉起子进程（fork+exec）。调用方负责 restart_count。返回 0=成功。 */
static int spawn_service(svc_t *s)
{
    if (s->pid > 0) return 0;

    pid_t pid = fork();
    if (pid < 0) {
        svcd_log("service %s: fork failed: %s", s->name, strerror(errno));
        s->state = SV_FAILED;
        return -1;
    }
    if (pid == 0) {
        /* 子进程：独立进程组，防父进程信号误伤；cap 实装属后续任务（见 meow_svcd.md），
         * 此处仅保留 s->cap 字符串，不应用（平台支持与否未定）。 */
        (void)setpgid(0, 0);
        for (int i = 0; i < s->envc; i++) {
            char *eq = strchr(s->envbuf[i], '=');
            if (!eq) continue;
            *eq = '\0';
            (void)setenv(s->envbuf[i], eq + 1, 1);
        }
        execv(s->exec, s->argv);
        fprintf(stderr, "[meow_svcd] service %s execv %s: %s\n",
                s->name, s->exec, strerror(errno));
        _exit(127);
    }
    s->pid = pid;
    s->state = SV_RUNNING;
    s->run_since_ms = now_ms();
    s->stop_requested = 0;
    s->restart_pending = 0;
    s->restart_at_ms = 0;
    svcd_log("service %s start: pid=%d exec=%s", s->name, (int)pid, s->exec);
    return 0;
}

/* 停止一个运行/停止中服务。restart_after=1 → 停后立即重启（restart 命令）。
 * user=1 → 用户 stop（置 user_stopped，触发自动拉起被抑制）。 */
static void stop_service(svc_t *s, int restart_after, int user)
{
    if (user) s->user_stopped = 1;
    if (s->pid <= 0) {
        if (s->state == SV_RUNNING || s->state == SV_STOPPING) s->state = SV_STOPPED;
        if (restart_after) { s->restart_count = 0; s->user_stopped = 0; spawn_service(s); }
        return;
    }
    if (s->state == SV_STOPPING) { if (restart_after) s->restart_pending = 1; return; }
    s->stop_requested = 1;
    s->restart_pending = restart_after;
    s->state = SV_STOPPING;
    s->stop_since_ms = now_ms();
    (void)kill(s->pid, SIGTERM);
    svcd_log("service %s: SIGTERM (pid=%d)", s->name, (int)s->pid);
}

/* 对单个已死亡子进程应用退出（由 reap 调用）。 */
static void apply_exit(svc_t *s, int status)
{
    int failed = !(WIFEXITED(status) && WEXITSTATUS(status) == 0);
    s->pid = 0;
    s->last_exit_status = status;

    if (s->restart_pending) {
        /* restart 命令：停后原地重启，无视崩溃策略 */
        s->restart_pending = 0;
        s->stop_requested = 0;
        s->restart_count = 0;
        s->state = SV_STOPPED;
        svcd_log("service %s: restart -> respawn", s->name);
        spawn_service(s);
        return;
    }
    if (s->stop_requested) {
        s->stop_requested = 0;
        s->state = SV_STOPPED;
        svcd_log("service %s: stopped (exit=%s)", s->name, failed ? "fail" : "ok");
        return;
    }

    /* 非受控退出 → 崩溃处理 */
    int want = 0;
    if      (strcmp(s->restart, "always") == 0)  want = 1;
    else if (strcmp(s->restart, "on-fail") == 0) want = failed;
    /* never → want=0 */

    if (want) {
        s->restart_count++;
        if (s->max_restart >= 0 && s->restart_count > s->max_restart) {
            s->state = SV_FAILED;
            svcd_log("service %s: exceeded max_restart(%d) -> FAILED (exit=%s)",
                     s->name, s->max_restart, failed ? "fail" : "ok");
        } else {
            long wait = s->backoff_ms;
            s->restart_at_ms = now_ms() + (unsigned long long)wait;
            s->state = SV_STOPPED;
            svcd_log("service %s: restart in %ldms (attempt %d, exit=%s)",
                     s->name, wait, s->restart_count, failed ? "fail" : "ok");
        }
    } else {
        s->state = failed ? SV_FAILED : SV_STOPPED;
        svcd_log("service %s: exit (policy=%s, %s) -> %s",
                 s->name, s->restart, failed ? "fail" : "ok",
                 failed ? "FAILED" : "STOPPED");
    }
}

/* SIGCHLD 处理器：写自管道唤醒 poll（async-signal-safe）。 */
static void sig_child(int sig)
{
    (void)sig;
    char c = SVCD_SIGCHLD_CHAR;
    ssize_t w = write(g_sigpipe[1], &c, 1);
    (void)w;
}

static void sig_term(int sig)
{
    (void)sig;
    g_shutdown = 1;
    char c = SVCD_SIGTERM_CHAR;
    ssize_t w = write(g_sigpipe[1], &c, 1);
    (void)w;
}

/* 排空 SIGCHLD 自管道，waitpid 匹配所有已退出子进程。 */
static void reap_children(void)
{
    char buf[64];
    while (read(g_sigpipe[0], buf, sizeof buf) > 0) { /* drain */ }

    int status;
    pid_t pid;
    while ((pid = waitpid(-1, &status, WNOHANG)) > 0) {
        int idx = -1;
        for (int i = 0; i < g_nsvc; i++)
            if (g_svcs[i].pid == pid) { idx = i; break; }
        if (idx < 0) { svcd_log("reap unknown pid=%d", (int)pid); continue; }
        apply_exit(&g_svcs[idx], status);
    }
    build_status_file();
}

/* ---- 触发判定 ---- */
static int trigger_satisfied(const svc_t *s)
{
    switch (s->trigger[0]) {
    case 'c':                    /* card-mount */
        return g_card_present;
    case 'w':                    /* wifi-up */
        return g_card_present && g_wifi_up;
    case 'b':                    /* boot：板载服务恒定存在，触发不依赖卡；TF 服务仍需卡 */
    default:
        return (s->src == 1) ? 1 : g_card_present;
    }
}

static int wifi_up(void)
{
    DIR *d = opendir("/sys/class/net");
    if (!d) return 0;
    int up = 0;
    struct dirent *e;
    while ((e = readdir(d)) != NULL) {
        if (e->d_name[0] == '.') continue;
        char wp[256], oper[256];
        if (snprintf(wp, sizeof wp, "/sys/class/net/%s/wireless", e->d_name)
            >= (int)sizeof wp) continue;
        if (access(wp, F_OK) != 0) continue;      /* 非无线接口 */
        if (snprintf(oper, sizeof oper, "/sys/class/net/%s/operstate", e->d_name)
            >= (int)sizeof oper) continue;
        char buf[16];
        if (read_file(oper, buf, sizeof buf) > 0 && strstr(buf, "up")) { up = 1; break; }
    }
    closedir(d);
    return up;
}

/* ---- 卡挂载检测 / 配置扫描 ---- */
static int card_present(void)
{
    const char *ov = getenv("MEOW_SVCD_CARD_PRESENT");
    if (ov && ov[0]) return ov[0] == '1';

    struct stat st, pst;
    if (stat(g_card, &st) != 0 || !S_ISDIR(st.st_mode)) return 0;

    /* 配置子目录存在 → 有卡内容（设备+宿主 test 通用） */
    char sp[512];
    if (snprintf(sp, sizeof sp, "%s/%s", g_card, SVCD_SERVICES_REL)
        >= (int)sizeof sp) return 0;
    if (access(sp, F_OK) == 0) return 1;

    /* 真实挂载点：st_dev 与父目录不同（卡文件系统 vs rootfs） */
    size_t plen = strlen(g_card);
    while (plen > 1 && g_card[plen - 1] == '/') g_card[--plen] = '\0';
    size_t slash = 0;
    for (size_t i = plen; i > 0; i--)
        if (g_card[i - 1] == '/') { slash = i; break; }
    if (slash == 0) return 0;
    char parent[384];
    if ((size_t)snprintf(parent, sizeof parent, "%.*s", (int)(slash - 1), g_card)
        >= sizeof parent) return 0;
    if (stat(parent, &pst) == 0 && pst.st_dev != st.st_dev) return 1;

    return 0;   /* 同文件系统空目录 = 未挂载/未用 */
}

static int board_services_exist(void)
{
    struct stat st;
    if (stat(g_board_dir, &st) != 0 || !S_ISDIR(st.st_mode)) return 0;
    return 1;
}

static int name_in_list(const char *name, char list[][SVCD_NAME_MAX], int n)
{
    for (int i = 0; i < n; i++)
        if (strcmp(list[i], name) == 0) return i;
    return -1;
}

/* 枚举某目录下的 *.conf，去除 .conf 得服务名。返回个数。 */
static int scan_conf_names(const char *dir, char out[][SVCD_NAME_MAX], int max)
{
    DIR *d = opendir(dir);
    if (!d) return 0;
    int n = 0;
    struct dirent *e;
    while ((e = readdir(d)) != NULL && n < max) {
        if (e->d_name[0] == '.') continue;
        size_t l = strlen(e->d_name);
        if (l < 6 || strcmp(e->d_name + l - 5, ".conf") != 0) continue;
        size_t nl = l - 5;                       /* 去掉 .conf 得服务名 */
        if (nl >= SVCD_NAME_MAX) nl = SVCD_NAME_MAX - 1;
        memcpy(out[n], e->d_name, nl);
        out[n][nl] = '\0';
        n++;
    }
    closedir(d);
    return n;
}

/* 双源目录调和：板载（恒定存在、权威优先）先扫，卡上有则叠加扫 TF，
 * 同名服务 TF 被板载屏蔽（WARN 记录）。无双源冲突时行为不变。 */
static void scan_and_reconcile(void)
{
    char names[SVCD_MAX_SERVICES][SVCD_NAME_MAX];
    char srcdir[SVCD_MAX_SERVICES][SVCD_PATH_MAX];   /* 每服务实际 .conf 所在目录 */
    int n = 0;

    if (board_services_exist()) {
        int nb = scan_conf_names(g_board_dir, names, SVCD_MAX_SERVICES);
        for (int i = 0; i < nb; i++)
            safe_strcpy(srcdir[i], sizeof srcdir[0], g_board_dir);
        n = nb;
    }

    if (g_card_present) {
        char tfdir[SVCD_PATH_MAX];
        if (snprintf(tfdir, sizeof tfdir, "%s/%s", g_card, SVCD_SERVICES_REL)
            < (int)sizeof tfdir) {
            char tfnames[SVCD_MAX_SERVICES][SVCD_NAME_MAX];
            int nt = scan_conf_names(tfdir, tfnames, SVCD_MAX_SERVICES);
            for (int t = 0; t < nt; t++) {
                if (name_in_list(tfnames[t], names, n) >= 0) {
                    svcd_log("%s 板载与 TF 都存在，采用板载", tfnames[t]);
                    continue;
                }
                if (n >= SVCD_MAX_SERVICES) {
                    svcd_log("service table full, drop %s", tfnames[t]); continue;
                }
                safe_strcpy(names[n], sizeof names[0], tfnames[t]);
                safe_strcpy(srcdir[n], sizeof srcdir[0], tfdir);
                n++;
            }
        }
    }

    for (int i = 0; i < g_nsvc; i++) g_svcs[i].in_config = 0;

    for (int i = 0; i < n; i++) {
        char path[512];
        if (snprintf(path, sizeof path, "%s/%s.conf", srcdir[i], names[i])
            >= (int)sizeof path) continue;
        int idx = find_svc(names[i]);
        if (idx < 0) {
            if (g_nsvc >= SVCD_MAX_SERVICES) { svcd_log("service table full, drop %s", names[i]); continue; }
            idx = g_nsvc++;
        }
        svc_t tmp;
        if (load_conf(path, names[i], &tmp) != 0) { continue; }
        tmp.src = (strcmp(srcdir[i], g_board_dir) == 0) ? 1 : 0;
        svc_t *s = &g_svcs[idx];

        /* 判定是否需重启（结构字段变化） */
        int config_changed = (strcmp(s->exec, tmp.exec) != 0)
            || (s->argc != tmp.argc) || (s->envc != tmp.envc)
            || (s->enabled != tmp.enabled);
        if (!config_changed) {
            for (int a = 0; a < tmp.argc; a++)
                if (strcmp(s->argv[a + 1], tmp.argv[a + 1]) != 0) { config_changed = 1; break; }
            for (int e2 = 0; e2 < tmp.envc; e2++)
                if (strcmp(s->envbuf[e2], tmp.envbuf[e2]) != 0) { config_changed = 1; break; }
        }

        /* 保留运行期字段，其余用 tmp 覆盖 */
        int keep_count = s->restart_count;
        int keep_exit  = s->last_exit_status;
        pid_t keep_pid = s->pid;
        int keep_stop  = s->stop_requested;
        int keep_rp    = s->restart_pending;
        int keep_user  = s->user_stopped;
        int keep_state = s->state;
        *s = tmp;
        s->restart_count = keep_count;
        s->last_exit_status = keep_exit;
        s->pid = keep_pid;
        s->stop_requested = keep_stop;
        s->restart_pending = keep_rp;
        s->user_stopped = keep_user;
        s->in_config = 1;
        s->restart_at_ms = 0;

        /* 子进程仍存活：配置变 → 停后按新配置重启；不变 → 维持 RUNNING/STOPPING，
         * 绝不能被 tmp 的 STOPPED 覆盖成「停了却还有 pid」的泄漏态。 */
        if (keep_pid > 0) {
            if (config_changed) {
                svcd_log("service %s: config changed, restart", s->name);
                stop_service(s, 1, 0);
            } else {
                s->state = (keep_state == SV_STOPPING) ? SV_STOPPING : SV_RUNNING;
            }
        } else {
            s->state = SV_STOPPED;
        }
    }

    /* 已移除配置的服务，倒序删（先停运行中的） */
    for (int i = g_nsvc - 1; i >= 0; i--) {
        if (g_svcs[i].in_config) continue;
        if (g_svcs[i].pid > 0) stop_service(&g_svcs[i], 0, 0);
        svcd_log("service %s: removed (no config)", g_svcs[i].name);
        remove_svc_idx(i);
    }

    /* 禁用：运行中 → 停；未运行 → DISABLED */
    for (int i = 0; i < g_nsvc; i++) {
        svc_t *s = &g_svcs[i];
        if (!s->in_config) continue;
        if (!s->enabled) {
            if (s->pid > 0) { svcd_log("service %s: disabled -> stop", s->name); stop_service(s, 0, 0); }
            else s->state = SV_DISABLED;
        }
    }

    /* 曾 FAILED 且现启用 → 重置，交 tick 重试 */
    for (int i = 0; i < g_nsvc; i++) {
        svc_t *s = &g_svcs[i];
        if (s->in_config && s->enabled && s->state == SV_FAILED) {
            s->restart_count = 0;
            s->state = SV_STOPPED;
            s->user_stopped = 0;
        }
    }
    build_status_file();
}

static void on_card_out(void)
{
    for (int i = 0; i < g_nsvc; i++) {
        svc_t *s = &g_svcs[i];
        s->restart_at_ms = 0;
        /* 拔卡后 trigger 仍满足的服务（板载-boot）不随卡停止（板载服务保留，MDNS 等常驻） */
        if (s->pid > 0 && trigger_satisfied(s)) continue;
        if (s->pid > 0) { stop_service(s, 0, 0); }
        else if (s->state == SV_RUNNING || s->state == SV_STOPPING) s->state = SV_STOPPED;
    }
    svcd_log("card removed: stopping %d services", g_nsvc);
    build_status_file();
}

static void tick_evaluate(void)
{
    for (int i = 0; i < g_nsvc; i++) {
        svc_t *s = &g_svcs[i];
        /* STOPPING 先判（含 SIGKILL 兜底），否则 pid>0 分支会吞掉超时逻辑 */
        if (s->state == SV_STOPPING) {
            if (now_ms() - s->stop_since_ms > SVCD_STOP_GRACE_MS) {
                if (s->pid > 0) { kill(s->pid, SIGKILL); s->pid = 0; }
                s->state = SV_STOPPED;
                svcd_log("service %s: SIGKILL grace timeout", s->name);
            }
            continue;
        }
        if (s->pid > 0) {
            if (!s->enabled || !trigger_satisfied(s))
                stop_service(s, 0, 0);
            if (s->pid > 0 && s->state == SV_RUNNING &&
                now_ms() - s->run_since_ms > SVCD_STABLE_MS)
                s->restart_count = 0;               /* 稳定运行 → 清零计数 */
            continue;
        }
        if (s->state == SV_FAILED || s->state == SV_DISABLED) continue;

        if (s->restart_at_ms > 0) {
            if (now_ms() >= s->restart_at_ms && trigger_satisfied(s)) {
                s->restart_at_ms = 0;
                svcd_log("service %s: backoff done, respawn", s->name);
                spawn_service(s);
            }
        } else if (s->enabled && trigger_satisfied(s) && !s->user_stopped) {
            spawn_service(s);
        }
    }
}

/* ---- 控制通道 ---- */
static void send_resp(int fd, const char *s)
{
    ssize_t w = write(fd, s, strlen(s));
    (void)w;
}

static int cmd_start(const char *name)
{
    if (strcmp(name, "all") == 0) {
        for (int i = 0; i < g_nsvc; i++) {
            g_svcs[i].user_stopped = 0;
            g_svcs[i].restart_count = 0;
            g_svcs[i].state = SV_STOPPED;
            spawn_service(&g_svcs[i]);
        }
        return 0;
    }
    int idx = find_svc(name);
    if (idx < 0) return -1;
    svc_t *s = &g_svcs[idx];
    s->user_stopped = 0;
    if (s->pid <= 0) { s->restart_count = 0; s->state = SV_STOPPED; spawn_service(s); }
    return 0;
}

static int cmd_stop(const char *name)
{
    if (strcmp(name, "all") == 0) {
        for (int i = 0; i < g_nsvc; i++) stop_service(&g_svcs[i], 0, 1);
        return 0;
    }
    int idx = find_svc(name);
    if (idx < 0) return -1;
    stop_service(&g_svcs[idx], 0, 1);
    return 0;
}

static int cmd_restart(const char *name)
{
    if (strcmp(name, "all") == 0) {
        for (int i = 0; i < g_nsvc; i++) stop_service(&g_svcs[i], 1, 0);
        return 0;
    }
    int idx = find_svc(name);
    if (idx < 0) return -1;
    svc_t *s = &g_svcs[idx];
    s->user_stopped = 0;
    if (s->pid <= 0) { s->restart_count = 0; s->state = SV_STOPPED; spawn_service(s); }
    else stop_service(s, 1, 0);
    return 0;
}

static void cmd_status(int fd)
{
    send_resp(fd, "# meow_svcd status\n");
    char line[384];
    int k = snprintf(line, sizeof line, "card_present=%d wifi_up=%d services=%d\n",
                     g_card_present, g_wifi_up, g_nsvc);
    send_resp(fd, line);
    (void)k;
    for (int i = 0; i < g_nsvc; i++) {
        svc_t *s = &g_svcs[i];
        snprintf(line, sizeof line,
                 "svc=%.63s state=%.16s pid=%d restart=%d exit=%d trigger=%.15s\n",
                 s->name, g_state_str[s->state], (int)s->pid, s->restart_count,
                 s->last_exit_status, s->trigger);
        send_resp(fd, line);
    }
}

/* 读一条命令并分发。返回响应内容（静态/栈缓冲由调用方使用）。 */
static void handle_connection(int fd)
{
    char buf[SVCD_LINE_MAX];
    ssize_t n = read(fd, buf, sizeof buf - 1);
    if (n <= 0) { send_resp(fd, "ERR empty\n"); return; }
    buf[n] = '\0';
    char *line = trim(buf);
    if (!line[0]) { send_resp(fd, "ERR empty\n"); return; }
    char *sp = strchr(line, ' ');
    if (sp) *sp++ = '\0';

    if (strcmp(line, "pid") == 0) {
        char r[64]; snprintf(r, sizeof r, "%d\n", (int)getpid()); send_resp(fd, r);
    } else if (strcmp(line, "status") == 0) {
        cmd_status(fd);
    } else if (strcmp(line, "reload") == 0) {
        scan_and_reconcile();
        send_resp(fd, "OK\n");
    } else if (sp && strcmp(line, "start") == 0) {
        send_resp(fd, cmd_start(sp) == 0 ? "OK\n" : "ERR no-such-service\n");
    } else if (sp && strcmp(line, "stop") == 0) {
        send_resp(fd, cmd_stop(sp) == 0 ? "OK\n" : "ERR no-such-service\n");
    } else if (sp && strcmp(line, "restart") == 0) {
        send_resp(fd, cmd_restart(sp) == 0 ? "OK\n" : "ERR no-such-service\n");
    } else {
        send_resp(fd, "ERR unknown-command\n");
    }
}

/* ---- Daemon 生命周期 ---- */

/* 绑定控制 socket。返回 0=成功。 */
static int setup_socket(void)
{
    unlink(g_sock);
    int fd = socket(AF_UNIX, SOCK_STREAM, 0);
    if (fd < 0) { svcd_log("socket: %s", strerror(errno)); return -1; }
    set_cloexec(fd);
    struct sockaddr_un a;
    memset(&a, 0, sizeof a);
    a.sun_family = AF_UNIX;
    safe_strcpy(a.sun_path, sizeof a.sun_path, g_sock);
    if (bind(fd, (struct sockaddr *)&a, sizeof a) != 0) {
        svcd_log("bind %s: %s", g_sock, strerror(errno));
        close(fd); return -1;
    }
    if (listen(fd, 4) != 0) { svcd_log("listen: %s", strerror(errno)); close(fd); return -1; }
    g_listen_fd = fd;
    return 0;
}

static int setup_signals(void)
{
    if (pipe(g_sigpipe) != 0) { svcd_log("pipe: %s", strerror(errno)); return -1; }
    /* 双端 O_NONBLOCK：drain 循环读到空即停，绝不阻塞在 read 上（否则 SIGCHLD
     * 唤醒 poll → 进入 reap_children → 第二次 read 阻塞，守护进程卡死）。 */
    int rf = fcntl(g_sigpipe[0], F_GETFL, 0);
    if (rf >= 0) fcntl(g_sigpipe[0], F_SETFL, rf | O_NONBLOCK);
    int wf = fcntl(g_sigpipe[1], F_GETFL, 0);
    if (wf >= 0) fcntl(g_sigpipe[1], F_SETFL, wf | O_NONBLOCK);
    set_cloexec(g_sigpipe[0]);
    set_cloexec(g_sigpipe[1]);

    struct sigaction sa;
    memset(&sa, 0, sizeof sa);
    sa.sa_handler = sig_child;
    sigemptyset(&sa.sa_mask);
    sa.sa_flags = 0;                 /* 无 SA_RESTART：让 poll 中断 */
    sigaction(SIGCHLD, &sa, NULL);

    struct sigaction st;
    memset(&st, 0, sizeof st);
    st.sa_handler = sig_term;
    sigemptyset(&st.sa_mask);
    st.sa_flags = 0;
    sigaction(SIGTERM, &st, NULL);
    sigaction(SIGINT, &st, NULL);

    signal(SIGPIPE, SIG_IGN);        /* 服务关管道不杀 svcd（崩溃隔离一环） */
    return 0;
}

static void daemonize(void)
{
    pid_t pid = fork();
    if (pid < 0) { svcd_log("fork: %s", strerror(errno)); }
    if (pid > 0) _exit(0);
    if (setsid() < 0) { /* ignore */ }
    pid = fork();
    if (pid < 0) { svcd_log("fork2: %s", strerror(errno)); }
    if (pid > 0) _exit(0);
    /* 清 cwd + stdio 到 /dev/null（日志走 g_log，若无则静默丢弃） */
    if (chdir("/") != 0) { /* ignore */ }
    int nul = open("/dev/null", O_RDWR);
    if (nul >= 0) { dup2(nul, 0); dup2(nul, 1); dup2(nul, 2); if (nul > 2) close(nul); }
}

static void write_pidfile(void)
{
    char buf[32];
    int l = snprintf(buf, sizeof buf, "%d\n", (int)getpid());
    (void)write_file(g_pidfile, buf, (size_t)l);
}

static void shutdown_all(void)
{
    for (int i = 0; i < g_nsvc; i++) {
        if (g_svcs[i].pid > 0) {
            kill(g_svcs[i].pid, SIGTERM);
            unsigned long long wait_until = now_ms() + 1500;
            while (g_svcs[i].pid > 0 && now_ms() < wait_until) {
                int st; pid_t p = waitpid(g_svcs[i].pid, &st, WNOHANG);
                if (p == g_svcs[i].pid) { g_svcs[i].pid = 0; }
                else usleep(50000);
            }
            if (g_svcs[i].pid > 0) { kill(g_svcs[i].pid, SIGKILL); g_svcs[i].pid = 0; }
        }
    }
    build_status_file();
    if (g_listen_fd >= 0) close(g_listen_fd);
    if (g_status_fd >= 0) close(g_status_fd);
    unlink(g_sock);
    unlink(g_pidfile);
}

static int start_daemon(void)
{
    if (setup_signals() != 0) return 1;
    if (setup_socket() != 0) return 1;
    write_pidfile();

    /* 打开状态文件（留存期读写） */
    g_status_fd = open(g_status, O_RDWR | O_CREAT, 0644);
    if (g_status_fd < 0) svcd_log("status file open fail: %s", strerror(errno));
    else set_cloexec(g_status_fd);

    /* 初始卡探测 + 板载服务目录状态 */
    g_card_present = card_present();
    g_board_online = board_services_exist();
    scan_and_reconcile();       /* 板载服务恒在，无卡也扫；卡上有则叠加扫 TF */

    svcd_log("meow_svcd up: card=%s present=%d board=%s sock=%s pid=%d",
             g_card, g_card_present, g_board_dir, g_sock, (int)getpid());

    struct pollfd pfds[2];
    nfds_t nfds = 2;

    unsigned long long last_scan = 0;
    while (!g_shutdown) {
        /* 计算 poll 超时：取最早退避到期与扫描周期的最小值 */
        unsigned long long soon = 0;
        for (int i = 0; i < g_nsvc; i++) {
            if (g_svcs[i].restart_at_ms > 0) {
                unsigned long long d = g_svcs[i].restart_at_ms > now_ms()
                                     ? g_svcs[i].restart_at_ms - now_ms() : 0;
                if (soon == 0 || d < soon) soon = d;
            }
        }
        int timeout = (soon > 0 && soon < (unsigned long long)SVCD_TICK_MAX_MS)
                      ? (int)soon : SVCD_TICK_MAX_MS;
        if (timeout < 5) timeout = 5;

        pfds[0].fd = g_listen_fd; pfds[0].events = POLLIN; pfds[0].revents = 0;
        pfds[1].fd = g_sigpipe[0]; pfds[1].events = POLLIN; pfds[1].revents = 0;

        int r = poll(pfds, nfds, timeout);
        if (r < 0) {
            if (errno == EINTR) continue;
            svcd_log("poll: %s", strerror(errno));
            break;
        }
        if (g_shutdown) break;

        if (pfds[0].revents & POLLIN) {
            int cfd = accept(g_listen_fd, NULL, NULL);
            if (cfd >= 0) {
                set_cloexec(cfd);
                handle_connection(cfd);
                close(cfd);
            }
        }
        if (pfds[1].revents & POLLIN) reap_children();

        /* 周期扫描卡/wifi（节流到 ~1s）；tick_evaluate 每醒来都跑（保 backoff 精度） */
        if (now_ms() - last_scan >= (unsigned long long)SVCD_SCAN_MS) {
            last_scan = now_ms();
            g_wifi_up = wifi_up();
            int present = card_present();
            if (present != g_card_present) {
                if (present) { g_card_present = 1; svcd_log("card mounted, rebuild"); scan_and_reconcile(); }
                else         { g_card_present = 0; on_card_out(); }
            }
            int bonline = board_services_exist();
            if (bonline != g_board_online) {
                g_board_online = bonline;
                svcd_log("board services dir %s %s, rebuild", g_board_dir, bonline ? "online" : "offline");
                scan_and_reconcile();
            }
        }
        tick_evaluate();
        build_status_file();
    }

    svcd_log("meow_svcd shutdown");
    shutdown_all();
    return 0;
}

/* ---- CLI ---- */
static int run_client(const char *cmdline)
{
    int fd = socket(AF_UNIX, SOCK_STREAM, 0);
    if (fd < 0) { fprintf(stderr, "[meow_svcd] socket: %s\n", strerror(errno)); return 2; }
    struct sockaddr_un a;
    memset(&a, 0, sizeof a);
    a.sun_family = AF_UNIX;
    safe_strcpy(a.sun_path, sizeof a.sun_path, g_sock);
    if (connect(fd, (struct sockaddr *)&a, sizeof a) != 0) {
        /* daemon 未运行 → 显示状态文件（若有） */
        fprintf(stderr, "[meow_svcd] daemon not running (%s): %s\n", g_sock, strerror(errno));
        close(fd);
        char *buf = malloc(8192);
        if (buf && read_file(g_status, buf, 8192) > 0) { fputs(buf, stdout); free(buf); }
        else if (buf) { free(buf); printf("card_present=0 services=0\n"); }
        return 1;
    }
    ssize_t w = write(fd, cmdline, strlen(cmdline));
    (void)w;
    shutdown(fd, SHUT_WR);
    char rbuf[8192];
    ssize_t n;
    while ((n = read(fd, rbuf, sizeof rbuf - 1)) > 0) {
        rbuf[n] = '\0';
        fputs(rbuf, stdout);
    }
    close(fd);
    return 0;
}

static void usage(const char *argv0)
{
    fprintf(stderr,
        "usage: %s [options] [command]\n"
        "  commands: start <name|all> | stop <name|all> | restart <name|all>\n"
        "            | status | reload | pid\n"
        "  no command  -> start daemon (default; -f/--foreground keeps fg for supervisor)\n"
        "  options:\n"
        "    -f, --foreground    stay in foreground (supervisor fork/exec 托管)\n"
        "    --card <path>       TF card mount point (default /usr/data/mnt/sd_0)\n"
        "    --board <path>      board services dir (default /usr/data/meow/services.d)\n"
        "    --sock <path>       control socket (default /tmp/meow_svcd.sock)\n"
        "    --status <path>     status file (default /tmp/meow_svcd.status)\n"
        "    --pidfile <path>    pid file (default /tmp/meow_svcd.pid)\n"
        "    --log <path>        also append svcd log to <path>\n",
        argv0);
}

int main(int argc, char **argv)
{
    /* 收集命令及其参数：首个非选项 token 为命令，其后非选项 token 拼接为其参数
     * （如 `stop all`、`restart foo`）。选项可出现在任意位置。 */
    const char *cmd_tok[16];
    int cmd_n = 0;
    for (int i = 1; i < argc; i++) {
        const char *a = argv[i];
        if      (strcmp(a, "-f") == 0 || strcmp(a, "--foreground") == 0) g_fg = 1;
        else if (strcmp(a, "--card") == 0 && i + 1 < argc)  safe_strcpy(g_card, sizeof g_card, argv[++i]);
        else if (strcmp(a, "--board") == 0 && i + 1 < argc) safe_strcpy(g_board_dir, sizeof g_board_dir, argv[++i]);
        else if (strcmp(a, "--sock") == 0 && i + 1 < argc)  safe_strcpy(g_sock, sizeof g_sock, argv[++i]);
        else if (strcmp(a, "--status") == 0 && i + 1 < argc) safe_strcpy(g_status, sizeof g_status, argv[++i]);
        else if (strcmp(a, "--pidfile") == 0 && i + 1 < argc) safe_strcpy(g_pidfile, sizeof g_pidfile, argv[++i]);
        else if (strcmp(a, "--log") == 0 && i + 1 < argc)   safe_strcpy(g_log, sizeof g_log, argv[++i]);
        else if (a[0] == '-') { usage(argv[0]); return 2; }
        else if (cmd_n < 16) cmd_tok[cmd_n++] = a;
    }

    /* env 覆盖 */
    const char *e;
    if ((e = getenv("MEOW_SVCD_CARD"))   && e[0]) safe_strcpy(g_card,   sizeof g_card, e);
    if ((e = getenv("MEOW_SVCD_BOARD"))  && e[0]) safe_strcpy(g_board_dir, sizeof g_board_dir, e);
    if ((e = getenv("MEOW_SVCD_SOCK"))   && e[0]) safe_strcpy(g_sock,   sizeof g_sock, e);
    if ((e = getenv("MEOW_SVCD_STATUS")) && e[0]) safe_strcpy(g_status, sizeof g_status, e);
    if ((e = getenv("MEOW_SVCD_LOG"))    && e[0]) safe_strcpy(g_log,    sizeof g_log, e);

    setvbuf(stderr, NULL, _IONBF, 0);

    if (cmd_n > 0) {
        char buf[SVCD_LINE_MAX];
        buf[0] = '\0';
        size_t off = 0;
        for (int i = 0; i < cmd_n; i++) {
            int k = snprintf(buf + off, sizeof buf - off, "%s%s", i ? " " : "", cmd_tok[i]);
            if (k < 0 || (size_t)k >= sizeof buf - off) break;
            off += (size_t)k;
        }
        return run_client(buf);
    }

    if (!g_fg) daemonize();
    return start_daemon();
}