$(echo <?php
/**
 * Plugin Name: Xiaoer AI Publish API
 * Description: 为外部 AI 写作工作流提供带 SEO 字段的文章发布接口（xiaoer/v1）。
 * Version: 1.0.0
 */

defined('ABSPATH') || exit;

define('XIAOER_PUB_KEY_FILE', '/www/server/xiaoer-settings/publish-key.php');
define('XIAOER_PUB_LOG', WP_CONTENT_DIR . '/.xiaoer-publish.log');
define('XIAOER_PUB_SEEN', 'xiaoer_pub_seen');
define('XIAOER_PUB_CACHE_DIR', '/www/server/fastcgi_cache');
define('XIAOER_PUB_BRAND', '小二项目网');
define('XIAOER_PUB_CDN_HOST', 'cdn.xiaoerpro.com');

/* ------------------------------------------------------------------ *
 * 基础设施
 * ------------------------------------------------------------------ */

function xiaoer_pub_key()
{
    static $key = null;
    if ($key !== null) {
        return $key;
    }
    $key = '';
    if (is_readable(XIAOER_PUB_KEY_FILE)) {
        $data = include XIAOER_PUB_KEY_FILE;
        if (is_array($data) && !empty($data['key']) && is_string($data['key'])) {
            $key = $data['key'];
        }
    }
    return $key;
}

function xiaoer_pub_log($msg)
{
    if (!is_string($msg)) {
        $msg = wp_json_encode($msg);
    }
    @file_put_contents(XIAOER_PUB_LOG, date('Y-m-d H:i:s') . ' ' . $msg . "\n", FILE_APPEND);
    if (@filesize(XIAOER_PUB_LOG) > 1048576) {
        @file_put_contents(XIAOER_PUB_LOG, '');
    }
}

function xiaoer_pub_auth($request)
{
    if (xiaoer_pub_key() === '') {
        return new WP_Error('xiaoer_no_key', '服务端未配置发布密钥', array('status' => 503));
    }

    $given = (string) $request->get_header('x_xiaoer_key');
    if ($given === '') {
        $auth = (string) $request->get_header('authorization');
        if ($auth !== '' && stripos($auth, 'bearer ') === 0) {
            $given = trim(substr($auth, 7));
        }
    }

    if ($given === '' || !hash_equals(xiaoer_pub_key(), $given)) {
        xiaoer_pub_log('auth_fail ip=' . ($_SERVER['REMOTE_ADDR'] ?? '?'));
        return new WP_Error('xiaoer_forbidden', '密钥无效', array('status' => 401));
    }
    return true;
}

/* ------------------------------------------------------------------ *
 * 路由
 * ------------------------------------------------------------------ */

add_action('rest_api_init', function () {
    $perm = 'xiaoer_pub_auth';

    register_rest_route('xiaoer/v1', '/health', array(
        'methods'             => 'GET',
        'permission_callback' => $perm,
        'callback'            => function () {
            return array(
                'ok'      => true,
                'site'    => home_url('/'),
                'brand'   => XIAOER_PUB_BRAND,
                'time'    => current_time('mysql'),
                'version' => '1.0.0',
            );
        },
    ));

    register_rest_route('xiaoer/v1', '/context', array(
        'methods'             => 'GET',
        'permission_callback' => $perm,
        'callback'            => 'xiaoer_pub_context',
    ));

    register_rest_route('xiaoer/v1', '/publish', array(
        'methods'             => 'POST',
        'permission_callback' => $perm,
        'callback'            => 'xiaoer_pub_publish',
    ));
});

function xiaoer_pub_context()
{
    $cats = array();
    foreach (get_categories(array('hide_empty' => false)) as $c) {
        $cats[] = array(
            'id'    => (int) $c->term_id,
            'name'  => $c->name,
            'slug'  => $c->slug,
            'count' => (int) $c->count,
        );
    }

    $recent = array();
    $q      = new WP_Query(array(
        'post_type'           => 'post',
        'post_status'         => 'publish',
        'posts_per_page'      => 40,
        'ignore_sticky_posts' => true,
        'no_found_rows'       => true,
    ));
    foreach ($q->posts as $p) {
        $recent[] = array(
            'id'    => (int) $p->ID,
            'title' => get_the_title($p),
            'date'  => $p->post_date,
            'link'  => get_permalink($p),
        );
    }
    wp_reset_postdata();

    return array(
        'ok'         => true,
        'site'       => array('name' => get_bloginfo('name'), 'url' => home_url('/')),
        'brand'      => XIAOER_PUB_BRAND,
        'categories' => $cats,
        'recent'     => $recent,
        'rules'      => array(
            'seo_title_max' => 45,
            'seo_desc_min'  => 70,
            'seo_desc_max'  => 110,
            'body_min_chars' => 900,
        ),
    );
}

/* ------------------------------------------------------------------ *
 * 内容处理
 * ------------------------------------------------------------------ */

function xiaoer_pub_clean_html($html)
{
    $html = (string) $html;
    $html = preg_replace('#<(script|style|iframe|object|embed|form|link|meta)\b[^>]*>.*?</\1>#is', '', $html);
    $html = preg_replace('#<(script|style|iframe|object|embed|form|link|meta)\b[^>]*/?>#is', '', $html);
    $html = wp_kses_post($html);
    $html = preg_replace('#<p>\s*(&nbsp;|\s)*</p>#iu', '', $html);
    return trim($html);
}

function xiaoer_pub_text_len($html)
{
    $text = wp_strip_all_tags((string) $html);
    $text = preg_replace('/\s+/u', '', $text);
    return function_exists('mb_strlen') ? mb_strlen($text, 'UTF-8') : strlen($text);
}

function xiaoer_pub_norm_title($title)
{
    $t = wp_strip_all_tags((string) $title);
    $t = preg_replace('/[\s\x{3000}]+/u', '', $t);
    $t = preg_replace('/[\p{P}\p{S}]+/u', '', $t);
    return mb_strtolower(trim($t), 'UTF-8');
}

function xiaoer_pub_resolve_category($args)
{
    if (!empty($args['category_id'])) {
        $term = get_term((int) $args['category_id'], 'category');
        if ($term && !is_wp_error($term)) {
            return (int) $term->term_id;
        }
    }
    if (!empty($args['category'])) {
        $name = trim((string) $args['category']);
        $term = get_term_by('name', $name, 'category');
        if (!$term) {
            $term = get_term_by('slug', sanitize_title($name), 'category');
        }
        if ($term && !is_wp_error($term)) {
            return (int) $term->term_id;
        }
        return new WP_Error('xiaoer_bad_category', '分类不存在：' . $name, array('status' => 400));
    }
    return (int) get_option('default_category');
}

function xiaoer_pub_cdn_url($url)
{
    $url = trim((string) $url);
    if ($url === '' || stripos($url, 'http') !== 0) {
        return '';
    }
    $host = strtolower((string) parse_url($url, PHP_URL_HOST));
    if (in_array($host, array('xiaoerpro.com', 'www.xiaoerpro.com'), true)) {
        $url = preg_replace('#^https?://(www\.)?xiaoerpro\.com#i', 'https://' . XIAOER_PUB_CDN_HOST, $url);
    }
    return esc_url_raw($url);
}

function xiaoer_pub_write_meta($post_id, $arr)
{
    if (function_exists('zib_update_option_meta')) {
        foreach ($arr as $k => $v) {
            if ($v !== '') {
                zib_update_option_meta('post_meta', $k, $v, $post_id);
            }
        }
        return 'zib';
    }
    $data = get_post_meta($post_id, 'zib_other_data', true);
    $data = is_array($data) ? $data : array();
    foreach ($arr as $k => $v) {
        if ($v !== '') {
            $data[$k] = $v;
        }
    }
    update_post_meta($post_id, 'zib_other_data', $data);
    return 'fallback';
}

function xiaoer_pub_purge_cache()
{
    $dir = XIAOER_PUB_CACHE_DIR;
    if (!is_dir($dir) || !is_writable($dir)) {
        return -1;
    }
    $n = 0;
    foreach ((array) glob($dir . '/*', GLOB_ONLYDIR) as $l1) {
        foreach ((array) glob($l1 . '/*', GLOB_ONLYDIR) as $l2) {
            foreach ((array) glob($l2 . '/*') as $f) {
                if (is_file($f) && @unlink($f)) {
                    $n++;
                }
            }
        }
    }
    return $n;
}

/* ------------------------------------------------------------------ *
 * 发布
 * ------------------------------------------------------------------ */

function xiaoer_pub_publish($request)
{
    $p = $request->get_json_params();
    if (!is_array($p) || empty($p)) {
        $p = $request->get_params();
    }

    $title = isset($p['title']) ? trim(wp_strip_all_tags((string) $p['title'])) : '';
    $html  = isset($p['html']) ? (string) $p['html'] : (isset($p['content']) ? (string) $p['content'] : '');

    if ($title === '' || $html === '') {
        return new WP_Error('xiaoer_bad_request', 'title 和 html 必填', array('status' => 400));
    }
    if (mb_strlen($title, 'UTF-8') > 120) {
        return new WP_Error('xiaoer_bad_title', 'title 超过 120 字', array('status' => 400));
    }

    $html = xiaoer_pub_clean_html($html);
    $len  = xiaoer_pub_text_len($html);
    if ($len < 600) {
        return new WP_Error('xiaoer_short', '正文过短（' . $len . ' 字），至少 600 字', array('status' => 400));
    }

    // 频率限制：每小时最多 20 篇
    $bucket = 'xiaoer_pub_' . date('YmdH');
    $count  = (int) get_transient($bucket);
    if ($count >= 20) {
        return new WP_Error('xiaoer_rate', '本小时发布数已达上限 20', array('status' => 429));
    }

    // 选题去重
    $topic_key = isset($p['topic_key']) ? sanitize_text_field((string) $p['topic_key']) : '';
    if ($topic_key !== '') {
        $seen = (array) get_option(XIAOER_PUB_SEEN, array());
        if (isset($seen[$topic_key])) {
            return new WP_Error('xiaoer_dup_topic', '选题已写过：' . $topic_key, array(
                'status' => 409,
                'existing_post' => (int) $seen[$topic_key],
            ));
        }
    }

    // 标题去重
    $norm     = xiaoer_pub_norm_title($title);
    $existing = get_page_by_title($title, OBJECT, 'post');
    if ($existing && xiaoer_pub_norm_title($existing->post_title) === $norm) {
        return new WP_Error('xiaoer_dup_title', '同名文章已存在', array(
            'status'   => 409,
            'existing_post' => (int) $existing->ID,
            'existing_link' => get_permalink($existing),
        ));
    }

    $cat = xiaoer_pub_resolve_category($p);
    if (is_wp_error($cat)) {
        return $cat;
    }

    $status = isset($p['status']) ? strtolower((string) $p['status']) : 'draft';
    if (!in_array($status, array('draft', 'publish', 'future', 'pending'), true)) {
        $status = 'draft';
    }

    $post_date     = '';
    $post_date_gmt = '';
    if ($status === 'future') {
        $at = isset($p['publish_at']) ? trim((string) $p['publish_at']) : '';
        $ts = $at ? strtotime($at) : false;
        if (!$ts || $ts <= time()) {
            return new WP_Error('xiaoer_bad_date', 'future 状态需要合法的 publish_at（未来时间，格式 YYYY-MM-DD HH:MM:SS）', array('status' => 400));
        }
        $post_date     = date('Y-m-d H:i:s', $ts);
        $post_date_gmt = gmdate('Y-m-d H:i:s', $ts);
    }

    $author_id = isset($p['author_id']) ? (int) $p['author_id'] : 1;
    if (!get_userdata($author_id)) {
        $author_id = 1;
    }

    $desc = isset($p['seo_description']) ? trim(wp_strip_all_tags((string) $p['seo_description'])) : '';
    if ($desc === '') {
        $desc = wp_trim_words(wp_strip_all_tags($html), 60, '…');
    }
    $desc = mb_substr(preg_replace('/\s+/u', ' ', $desc), 0, 160, 'UTF-8');

    $postarr = array(
        'post_title'    => $title,
        'post_content'  => $html,
        'post_status'   => $status,
        'post_type'     => 'post',
        'post_author'   => $author_id,
        'post_category' => array($cat),
        'post_excerpt'  => $desc,
    );
    if ($post_date !== '') {
        $postarr['post_date']     = $post_date;
        $postarr['post_date_gmt'] = $post_date_gmt;
    }

    $post_id = wp_insert_post($postarr, true);
    if (is_wp_error($post_id)) {
        xiaoer_pub_log('insert_fail ' . $post_id->get_error_message());
        return new WP_Error('xiaoer_insert', '写入失败：' . $post_id->get_error_message(), array('status' => 500));
    }

    // 标签
    $tags = array();
    if (!empty($p['tags'])) {
        $tags = is_array($p['tags']) ? $p['tags'] : preg_split('/[,，、\s]+/u', (string) $p['tags']);
        $tags = array_values(array_filter(array_map('trim', $tags)));
        $tags = array_slice($tags, 0, 6);
        if ($tags) {
            wp_set_post_tags($post_id, $tags, false);
        }
    }

    // SEO 字段
    $seo_title = isset($p['seo_title']) ? trim(wp_strip_all_tags((string) $p['seo_title'])) : '';
    if ($seo_title === '') {
        $seo_title = $title . ' - ' . XIAOER_PUB_BRAND;
    }
    if (mb_strpos($seo_title, XIAOER_PUB_BRAND) === false) {
        $seo_title .= ' - ' . XIAOER_PUB_BRAND;
    }
    $seo_title = mb_substr($seo_title, 0, 60, 'UTF-8');

    $keywords = isset($p['seo_keywords']) ? trim(wp_strip_all_tags((string) $p['seo_keywords'])) : '';
    if ($keywords === '' && $tags) {
        $keywords = implode(',', $tags);
    }

    $cover = xiaoer_pub_cdn_url($p['cover_url'] ?? '');
    $meta_written = xiaoer_pub_write_meta($post_id, array(
        'title'         => $seo_title,
        'description'   => $desc,
        'keywords'      => $keywords,
        'cover_image'   => $cover,
        'thumbnail_url' => $cover,
    ));

    // 特色图（可选，失败不影响发布）
    $thumb          = 0;
    $thumb_error    = '';
    if ($cover !== '') {
        require_once ABSPATH . 'wp-admin/includes/file.php';
        require_once ABSPATH . 'wp-admin/includes/media.php';
        require_once ABSPATH . 'wp-admin/includes/image.php';
        $att = media_sideload_image($cover, $post_id, $title, 'id');
        if (is_wp_error($att)) {
            $thumb_error = $att->get_error_message();
        } else {
            set_post_thumbnail($post_id, (int) $att);
            $thumb = (int) $att;
        }
    }

    // 缓存
    $purged = 0;
    if (!isset($p['purge_cache']) || $p['purge_cache']) {
        $purged = xiaoer_pub_purge_cache();
        wp_cache_flush();
    }

    if ($topic_key !== '') {
        $seen = (array) get_option(XIAOER_PUB_SEEN, array());
        $seen[$topic_key] = (int) $post_id;
        if (count($seen) > 800) {
            $seen = array_slice($seen, -800, 800, true);
        }
        update_option(XIAOER_PUB_SEEN, $seen, false);
    }

    set_transient($bucket, $count + 1, HOUR_IN_SECONDS);

    $link = $status === 'publish' ? get_permalink($post_id) : get_preview_post_link($post_id);
    xiaoer_pub_log(sprintf(
        'publish id=%d status=%s cat=%d len=%d chars title=%s ip=%s',
        $post_id, $status, $cat, $len, $title, $_SERVER['REMOTE_ADDR'] ?? '?'
    ));

    return new WP_REST_Response(array(
        'ok'          => true,
        'id'          => (int) $post_id,
        'status'      => $status,
        'link'        => $link,
        'category'    => array('id' => $cat, 'name' => get_cat_name($cat)),
        'chars'       => $len,
        'seo'         => array(
            'title'       => $seo_title,
            'description' => $desc,
            'keywords'    => $keywords,
            'cover'       => $cover,
        ),
        'thumbnail_id' => $thumb,
        'meta_writer'  => $meta_written,
        'cache_purged' => $purged,
        'warnings'     => $thumb_error ? array('featured_image: ' . $thumb_error) : array(),
    ), 201);
}
 | base64 -d)
