完善日志系统，修复读取配置文件时的内存泄漏，初步添加熔断机制与指数退避机制

deleted:    requirements.txt
    deleted:    run.bat
	deleted:    run.sh
	deleted:    src/__init__.py
	deleted:    src/mainprocess.py

app.py

@@ -1,97 +0,0 @@
-import logging
-from flask import Flask, request, jsonify
-from logging.handlers import RotatingFileHandler
-from functools import wraps
-from datetime import datetime
-from src import mainprocess as src
-
-
-app = Flask(__name__)
-
-#===rebot===#
-# 处理私聊消息
-# 处理群聊消息
-@app.route('/', methods=["POST"])
-def handle_event():
-    try:
-        event = request.get_json()
-        event_type = event.get('post_type')
-        
-        # 1. 处理私聊消息
-        if event_type == 'message' and event.get('message_type') == 'private':
-            # 注意：私聊消息在顶层有 user_id
-            uid = event.get('user_id')
-            message = event.get('raw_message')
-            src.process_message(uid, None, message)
-            
-        # 2. 处理群消息
-        elif event_type == 'message' and event.get('message_type') == 'group':
-            gid = event.get('group_id')
-            # 注意：群消息发送者在 sender 内
-            sender = event.get('sender', {})
-            uid = sender.get('user_id')
-            message = event.get('raw_message')
-            src.process_message(uid, gid, message)
-
-        # 3. 处理通知事件（如输入状态）
-        elif event_type == 'notice':
-            notice_type = event.get('notice_type')
-            
-            if notice_type == 'notify' and event.get('sub_type') == 'input_status':
-                # 仅记录，不处理
-                logging.info(f"用户 {event.get('user_id')} 输入状态变化")
-                
-            elif notice_type == 'group_recall':
-                # 示例：处理群消息撤回
-                logging.info(f"群 {event.get('group_id')} 撤回消息")
-                
-            else:
-                # 其他通知类型
-                logging.info(f"Ignored notice: {event}")
-            
-            # 通知事件直接返回成功
-            return jsonify({
-                "status": "ok",
-                "retcode": 0,
-                "data": None
-            })
-            
-        # 4. 处理元事件（如心跳）
-        elif event_type == 'meta_event':
-            # 心跳等元事件直接返回成功
-            return jsonify({
-                "status": "ok",
-                "retcode": 0,
-                "data": None
-            })
-        
-        # 5. 一切正常的消息事件返回成功
-        return jsonify({
-            "status": "ok",
-            "retcode": 0,
-            "data": "Processed successfully"
-        })
-    
-    except KeyError:
-        logging.warning(f"Missing required field in event: {event}")
-        return jsonify({
-            "status": "failed",
-            "retcode": 10001,
-            "message": "Missing required field"
-        }), 400
-        
-    except Exception as e:
-        logging.exception(f"Error processing event: {str(e)}")
-        return jsonify({
-            "status": "failed",
-            "retcode": 20001,
-            "message": "Internal server error"
-        }), 500
-
-
-if __name__ == '__main__':
-    try:
-        port = 25580
-        app.run(debug=True, host='0.0.0.0', port=port)
-    except Exception as e:
-        print(f"启动失败: {e}")

c/CMakeLists.txt

@@ -0,0 +1,16 @@
+cmake_minimum_required(VERSION 3.28.3)
+
+project (Onebot_back C)
+
+add_executable(Start_Onebot_back main.c tem/ctl.c)
+add_executable(Run_pluginmanager run_pluginmanager/run_pluginmanager.c)
+add_library(Network SHARED network/network.c network/swap.c network/cJSON.c network/http/http_rel.c network/erroprocess/erroprocess.c)
+add_library(Swmem SHARED network/swap.c)
+add_library(Interpre SHARED interpreter/interpreter.c tools/pkgmanager/pkginstall.c)
+add_library(Log SHARED tools/log/log.c)
+add_library(Toml SHARED tools/toml/toml.c)
+add_library(Quit SHARED tools/quit/quit.c)
+
+target_link_libraries(Start_Onebot_back Network Swmem Interpre Log Toml Quit)
+
+include_directories(${PROJECT_SOURCE_DIR})

c/interpreter/interpreter.c

@@ -0,0 +1,218 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <stddef.h>
+#include <string.h>
+#include <termios.h>
+#include <stddef.h>
+#include "interpreter.h"
+#include "tools/pkgmanager/pkginstall.h"
+
+int inter_in_log(const char *log,log_manager *manager)
+{
+    if(strlen(log)>1024)
+        return -1;
+    logs* logss = (logs*)malloc(sizeof(logs));
+    memcpy(logss->log,log,strlen(log));
+    manager->in_log(logss,manager);
+    return 0;
+}
+
+int init_interpreter(Cmd *cmd_dic,ctx *self,int fifo[2],log_manager *log_manager)
+{
+    printf("SYS:prepare env\n");
+    inter_in_log("SYS:prepare env\n",log_manager);
+    printf("SYS:env ready\n");
+    inter_in_log("SYS:env ready\n",log_manager);
+    printf("SYS:loading cmd_dic\n");
+    inter_in_log("SYS:loading cmd_dic\n",log_manager);
+    sprintf(cmd_dic[0].name, "pkginstall");
+    cmd_dic[0].cmd = INSTALL;
+
+    sprintf(cmd_dic[1].name,"run");
+    cmd_dic[1].cmd = RUN;
+
+    sprintf(cmd_dic[2].name,"quit");
+    cmd_dic[2].cmd = QUIT;
+
+    printf("SYS:cmd_dir load complite\n");
+    inter_in_log("SYS:cmd_dir load complite\n",log_manager);
+
+    for(int i =0;i<10;i++)
+    {
+        self->space_index[i] = 0;
+    }
+    self->arg = NULL;
+    printf("SYS:Creating ctl fifo\n");
+    inter_in_log("SYS:Creating ctl fifo\n",log_manager);
+    memcpy(self->fifofd,fifo,2*sizeof(int));
+    self->log_manager = log_manager;
+}
+
+int get_args(ctx *self)
+{
+    int i;
+    if(self->space_index[0]==0)
+        return 0;
+    self->arg = (args*)malloc(sizeof(args));
+    args* arg = self->arg;
+    size_t len = 0;
+    //抽取参数
+    for(i =0;i<9;i++)
+    {
+        if(self->space_index[i+1]==0)
+            break;
+        len = self->space_index[i+1]-self->space_index[i]-1;
+        memcpy(arg->name,&self->command[self->space_index[i]+1],len);
+        arg->name[len] = '\0';
+        //拷贝变量到变量链
+        if(self->space_index[i+2]!=0){
+            arg->next = (args*)malloc(sizeof(args));
+            if(arg->next == NULL){
+                perror("ERROR:fail to get mem");
+                inter_in_log("ERROR:fail to get mem\n",self->log_manager);
+                return -1;
+            }
+            arg = arg->next;
+        }
+        //访问下一个节点
+    }
+
+
+    if(i<9)
+    {
+        len = self->line-self->space_index[i]-2;
+        memcpy(arg->name,&self->command[self->space_index[i]+1],len);
+        arg->name[len] = '\0';
+    }
+    arg->next = NULL;
+    return i;
+}
+
+int args_free(ctx *self)
+{
+    //释放节点使用的空间
+    if(self->arg == NULL)
+        return 1;
+    args *arg = self->arg;
+    args *buf = arg;
+    while(buf!= NULL&&arg->next!=NULL)
+    {
+        buf = arg;
+        arg = arg->next;
+        free(buf);
+    }
+    return 1;
+}
+
+//分割命令
+int split(const char *input,ctx *all_ctx)
+{
+    int sp_index = 0;
+    char buf = input[0];
+    int index = 0;
+    while(buf != '\n')
+    {
+        if(buf == ' '){
+            //记录空格位置
+            all_ctx->space_index[sp_index] = index;
+            sp_index++;
+        }
+        index++;
+        buf = input[index];
+    }
+}
+
+//匹配命令
+int match_cmd(const Cmd* cmd_dic,char *cmd_buf)
+{   
+    int cmd_index = 0;
+    
+    while(cmd_index <CMD_DIR_LENGTH)
+    {
+        if(strcmp(cmd_dic[cmd_index].name,cmd_buf)==0)
+            return cmd_dic[cmd_index].cmd;
+        cmd_index++;
+    }
+    return BAD_INPUT;
+}
+
+
+int exce(const int command,ctx *all_ctx)
+{
+
+    switch (command)
+    {
+    case BAD_INPUT:
+        printf("SYS:bad input,try again\n");
+        inter_in_log("SYS:bad input,try again\n",all_ctx->log_manager);
+        return BAD_INPUT;
+
+    case INSTALL:
+        if(all_ctx->arg == NULL){
+            printf("SYS:Missing args\n");
+            inter_in_log("SYS:Missng args\n",all_ctx->log_manager);
+            return 1;
+        }
+        printf("SYS:init pkgmanager\n");
+        inter_in_log("SYS:init pkgmanager\n",all_ctx->log_manager);
+        pkger *manager = init_pkginstaller();
+        printf("SYS:installing\n");
+        inter_in_log("SYS:installing\n",all_ctx->log_manager);
+        manager->packup(manager);
+        return 1;
+
+    case RUN:
+        printf("SYS:runing\n");
+        inter_in_log("SYS:running\n",all_ctx->log_manager);
+        return 1;
+        
+    case QUIT:
+        printf("SYS:shuting down\n");
+        inter_in_log("SYS:shuting down\n",all_ctx->log_manager);
+        all_ctx->statue = -1;
+        write(all_ctx->fifofd[1],"q",1);
+        return 1;
+    }
+
+}
+
+int interpret(int mod, ctx *all_ctx,Cmd *cmd_dic)
+{
+    if (mod == SIG_MOD)
+    {
+        // 检查空格位置
+
+        split(all_ctx->command,all_ctx);
+        get_args(all_ctx);
+        char *cmd_buf = malloc(MAX_BUF);
+        int len;
+        if(all_ctx->space_index[0]==0)
+        {
+            len = all_ctx->line;
+        }
+        else
+        {
+            len = all_ctx->space_index[0];
+        }
+        memcpy(cmd_buf,all_ctx->command,len);
+        if(cmd_buf[len-1] == '\n')
+            cmd_buf[len-1] = '\0';
+        //执行命令
+        exce(match_cmd(cmd_dic, cmd_buf),all_ctx);
+
+        //释放所有堆内存
+        free(cmd_buf);
+        args_free(all_ctx);
+        all_ctx->arg = NULL;
+        for(int i =0;i<10;i++)
+        {
+            all_ctx->space_index[i] = 0;
+        }
+    }
+
+    if (mod == FILE_MOD)
+    {
+    }
+}

c/interpreter/interpreter.h

@@ -0,0 +1,52 @@
+#ifndef INTERPRETER
+#define INTERPRETER
+
+#define MAX_BUF 256
+
+#define SIG_MOD 0
+#define FILE_MOD 1
+
+#include "tools/log/log.h"
+
+typedef struct
+{
+    char name[256];
+    int cmd;
+}Cmd;//配置关键词节点
+
+#define CMD_DIR_LENGTH 3
+
+//command 定义
+#define  INSTALL 0
+#define RUN 1
+#define QUIT 2
+#define BAD_INPUT -1
+
+typedef struct args
+{
+    void *loc;
+    int type;
+    char name[256];
+    struct args* next;
+}args;//参数链表
+
+typedef struct ctx
+{
+    int index;//当前位置
+    int space_index[10];//当前行空格位置
+    int line;//当前行长度
+    int word;//当前解释词位置
+    args *arg;//当前环境下参数链表
+    char command[MAX_BUF];//当前行缓存
+    int statue;//当前状态
+    int fifofd[2];
+    log_manager *log_manager;
+}ctx;//上下文管理
+
+
+int interpret(int mod, ctx *all_ctx,Cmd *cmd_dic);
+int init_interpreter(Cmd *cmd_dic,ctx *self,int fifo[2],log_manager *log_manager);
+
+#define ARG_LENGTH 256
+
+#endif

c/main.c

@@ -0,0 +1,62 @@
+#define _GNU_SOURCE
+#include "tem/ctl.h"
+#include "network/network.h"
+#include "tools/toml/toml.h"
+#include "tools/quit/quit.h"
+#include <unistd.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+int get_config(toml_table_t **server,char *path)
+{
+    FILE* fp;
+    char errbuf[200];
+    //打开配置文件，加载到缓存
+    fp = fopen(path,"r");
+    if(!fp)
+    {
+        perror("cannot parse\n");
+        return 0;
+    }
+    toml_table_t *tem = toml_parse_file(fp,errbuf,sizeof(errbuf));
+    tem = toml_table_in(tem,"app");
+    *server = tem;
+    fclose(fp);
+    return 1;
+}
+
+
+int main()
+{
+    toml_table_t* server;
+    if(!get_config(&server,"config/config.toml"))
+        perror("load config error");
+    int port = (int)toml_int_in(server,"list_port").u.i;
+    //加载配置文件，读取端口
+    log_manager *logsmanager=(log_manager*)malloc(sizeof(log_manager));
+    init_loger(logsmanager);
+
+    Ctl *teml = init_tem(logsmanager);
+    teml->config = server;
+    //初始化终端对象
+    int fifo[2];
+    if(pipe(fifo)==-1)
+        perror("ERROR ");
+    netm *networkmanager = (netm*)malloc(sizeof(netm));
+    init_networkmanager(networkmanager,fifo,logsmanager,port);
+    //初始化网络管理器对象
+    pthread_t network_id;
+    pthread_create(&network_id,NULL,networkmanager->run_network,(void*)networkmanager);
+    //启动网络监听与线程池，并加载插件
+    alres *resource = (alres*)malloc(sizeof(alres));
+    resource->loger = logsmanager;
+    resource->network = networkmanager;
+    resource->tem = teml;
+    on_exit(quit_all,resource);
+    //注册清理函数
+    teml->run(teml,fifo);
+    //启动终端
+    pthread_join(network_id,NULL);
+    //等待网络管理器进程结束
+    return 1;
+}

c/network/cJSON.h

@@ -0,0 +1,306 @@
+/*
+  Copyright (c) 2009-2017 Dave Gamble and cJSON contributors
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in
+  all copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+  THE SOFTWARE.
+*/
+
+#ifndef cJSON__h
+#define cJSON__h
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+#if !defined(__WINDOWS__) && (defined(WIN32) || defined(WIN64) || defined(_MSC_VER) || defined(_WIN32))
+#define __WINDOWS__
+#endif
+
+#ifdef __WINDOWS__
+
+/* When compiling for windows, we specify a specific calling convention to avoid issues where we are being called from a project with a different default calling convention.  For windows you have 3 define options:
+
+CJSON_HIDE_SYMBOLS - Define this in the case where you don't want to ever dllexport symbols
+CJSON_EXPORT_SYMBOLS - Define this on library build when you want to dllexport symbols (default)
+CJSON_IMPORT_SYMBOLS - Define this if you want to dllimport symbol
+
+For *nix builds that support visibility attribute, you can define similar behavior by
+
+setting default visibility to hidden by adding
+-fvisibility=hidden (for gcc)
+or
+-xldscope=hidden (for sun cc)
+to CFLAGS
+
+then using the CJSON_API_VISIBILITY flag to "export" the same symbols the way CJSON_EXPORT_SYMBOLS does
+
+*/
+
+#define CJSON_CDECL __cdecl
+#define CJSON_STDCALL __stdcall
+
+/* export symbols by default, this is necessary for copy pasting the C and header file */
+#if !defined(CJSON_HIDE_SYMBOLS) && !defined(CJSON_IMPORT_SYMBOLS) && !defined(CJSON_EXPORT_SYMBOLS)
+#define CJSON_EXPORT_SYMBOLS
+#endif
+
+#if defined(CJSON_HIDE_SYMBOLS)
+#define CJSON_PUBLIC(type)   type CJSON_STDCALL
+#elif defined(CJSON_EXPORT_SYMBOLS)
+#define CJSON_PUBLIC(type)   __declspec(dllexport) type CJSON_STDCALL
+#elif defined(CJSON_IMPORT_SYMBOLS)
+#define CJSON_PUBLIC(type)   __declspec(dllimport) type CJSON_STDCALL
+#endif
+#else /* !__WINDOWS__ */
+#define CJSON_CDECL
+#define CJSON_STDCALL
+
+#if (defined(__GNUC__) || defined(__SUNPRO_CC) || defined (__SUNPRO_C)) && defined(CJSON_API_VISIBILITY)
+#define CJSON_PUBLIC(type)   __attribute__((visibility("default"))) type
+#else
+#define CJSON_PUBLIC(type) type
+#endif
+#endif
+
+/* project version */
+#define CJSON_VERSION_MAJOR 1
+#define CJSON_VERSION_MINOR 7
+#define CJSON_VERSION_PATCH 19
+
+#include <stddef.h>
+
+/* cJSON Types: */
+#define cJSON_Invalid (0)
+#define cJSON_False  (1 << 0)
+#define cJSON_True   (1 << 1)
+#define cJSON_NULL   (1 << 2)
+#define cJSON_Number (1 << 3)
+#define cJSON_String (1 << 4)
+#define cJSON_Array  (1 << 5)
+#define cJSON_Object (1 << 6)
+#define cJSON_Raw    (1 << 7) /* raw json */
+
+#define cJSON_IsReference 256
+#define cJSON_StringIsConst 512
+
+/* The cJSON structure: */
+typedef struct cJSON
+{
+    /* next/prev allow you to walk array/object chains. Alternatively, use GetArraySize/GetArrayItem/GetObjectItem */
+    struct cJSON *next;
+    struct cJSON *prev;
+    /* An array or object item will have a child pointer pointing to a chain of the items in the array/object. */
+    struct cJSON *child;
+
+    /* The type of the item, as above. */
+    int type;
+
+    /* The item's string, if type==cJSON_String  and type == cJSON_Raw */
+    char *valuestring;
+    /* writing to valueint is DEPRECATED, use cJSON_SetNumberValue instead */
+    int valueint;
+    /* The item's number, if type==cJSON_Number */
+    double valuedouble;
+
+    /* The item's name string, if this item is the child of, or is in the list of subitems of an object. */
+    char *string;
+} cJSON;
+
+typedef struct cJSON_Hooks
+{
+      /* malloc/free are CDECL on Windows regardless of the default calling convention of the compiler, so ensure the hooks allow passing those functions directly. */
+      void *(CJSON_CDECL *malloc_fn)(size_t sz);
+      void (CJSON_CDECL *free_fn)(void *ptr);
+} cJSON_Hooks;
+
+typedef int cJSON_bool;
+
+/* Limits how deeply nested arrays/objects can be before cJSON rejects to parse them.
+ * This is to prevent stack overflows. */
+#ifndef CJSON_NESTING_LIMIT
+#define CJSON_NESTING_LIMIT 1000
+#endif
+
+/* Limits the length of circular references can be before cJSON rejects to parse them.
+ * This is to prevent stack overflows. */
+#ifndef CJSON_CIRCULAR_LIMIT
+#define CJSON_CIRCULAR_LIMIT 10000
+#endif
+
+/* returns the version of cJSON as a string */
+CJSON_PUBLIC(const char*) cJSON_Version(void);
+
+/* Supply malloc, realloc and free functions to cJSON */
+CJSON_PUBLIC(void) cJSON_InitHooks(cJSON_Hooks* hooks);
+
+/* Memory Management: the caller is always responsible to free the results from all variants of cJSON_Parse (with cJSON_Delete) and cJSON_Print (with stdlib free, cJSON_Hooks.free_fn, or cJSON_free as appropriate). The exception is cJSON_PrintPreallocated, where the caller has full responsibility of the buffer. */
+/* Supply a block of JSON, and this returns a cJSON object you can interrogate. */
+CJSON_PUBLIC(cJSON *) cJSON_Parse(const char *value);
+CJSON_PUBLIC(cJSON *) cJSON_ParseWithLength(const char *value, size_t buffer_length);
+/* ParseWithOpts allows you to require (and check) that the JSON is null terminated, and to retrieve the pointer to the final byte parsed. */
+/* If you supply a ptr in return_parse_end and parsing fails, then return_parse_end will contain a pointer to the error so will match cJSON_GetErrorPtr(). */
+CJSON_PUBLIC(cJSON *) cJSON_ParseWithOpts(const char *value, const char **return_parse_end, cJSON_bool require_null_terminated);
+CJSON_PUBLIC(cJSON *) cJSON_ParseWithLengthOpts(const char *value, size_t buffer_length, const char **return_parse_end, cJSON_bool require_null_terminated);
+
+/* Render a cJSON entity to text for transfer/storage. */
+CJSON_PUBLIC(char *) cJSON_Print(const cJSON *item);
+/* Render a cJSON entity to text for transfer/storage without any formatting. */
+CJSON_PUBLIC(char *) cJSON_PrintUnformatted(const cJSON *item);
+/* Render a cJSON entity to text using a buffered strategy. prebuffer is a guess at the final size. guessing well reduces reallocation. fmt=0 gives unformatted, =1 gives formatted */
+CJSON_PUBLIC(char *) cJSON_PrintBuffered(const cJSON *item, int prebuffer, cJSON_bool fmt);
+/* Render a cJSON entity to text using a buffer already allocated in memory with given length. Returns 1 on success and 0 on failure. */
+/* NOTE: cJSON is not always 100% accurate in estimating how much memory it will use, so to be safe allocate 5 bytes more than you actually need */
+CJSON_PUBLIC(cJSON_bool) cJSON_PrintPreallocated(cJSON *item, char *buffer, const int length, const cJSON_bool format);
+/* Delete a cJSON entity and all subentities. */
+CJSON_PUBLIC(void) cJSON_Delete(cJSON *item);
+
+/* Returns the number of items in an array (or object). */
+CJSON_PUBLIC(int) cJSON_GetArraySize(const cJSON *array);
+/* Retrieve item number "index" from array "array". Returns NULL if unsuccessful. */
+CJSON_PUBLIC(cJSON *) cJSON_GetArrayItem(const cJSON *array, int index);
+/* Get item "string" from object. Case insensitive. */
+CJSON_PUBLIC(cJSON *) cJSON_GetObjectItem(const cJSON * const object, const char * const string);
+CJSON_PUBLIC(cJSON *) cJSON_GetObjectItemCaseSensitive(const cJSON * const object, const char * const string);
+CJSON_PUBLIC(cJSON_bool) cJSON_HasObjectItem(const cJSON *object, const char *string);
+/* For analysing failed parses. This returns a pointer to the parse error. You'll probably need to look a few chars back to make sense of it. Defined when cJSON_Parse() returns 0. 0 when cJSON_Parse() succeeds. */
+CJSON_PUBLIC(const char *) cJSON_GetErrorPtr(void);
+
+/* Check item type and return its value */
+CJSON_PUBLIC(char *) cJSON_GetStringValue(const cJSON * const item);
+CJSON_PUBLIC(double) cJSON_GetNumberValue(const cJSON * const item);
+
+/* These functions check the type of an item */
+CJSON_PUBLIC(cJSON_bool) cJSON_IsInvalid(const cJSON * const item);
+CJSON_PUBLIC(cJSON_bool) cJSON_IsFalse(const cJSON * const item);
+CJSON_PUBLIC(cJSON_bool) cJSON_IsTrue(const cJSON * const item);
+CJSON_PUBLIC(cJSON_bool) cJSON_IsBool(const cJSON * const item);
+CJSON_PUBLIC(cJSON_bool) cJSON_IsNull(const cJSON * const item);
+CJSON_PUBLIC(cJSON_bool) cJSON_IsNumber(const cJSON * const item);
+CJSON_PUBLIC(cJSON_bool) cJSON_IsString(const cJSON * const item);
+CJSON_PUBLIC(cJSON_bool) cJSON_IsArray(const cJSON * const item);
+CJSON_PUBLIC(cJSON_bool) cJSON_IsObject(const cJSON * const item);
+CJSON_PUBLIC(cJSON_bool) cJSON_IsRaw(const cJSON * const item);
+
+/* These calls create a cJSON item of the appropriate type. */
+CJSON_PUBLIC(cJSON *) cJSON_CreateNull(void);
+CJSON_PUBLIC(cJSON *) cJSON_CreateTrue(void);
+CJSON_PUBLIC(cJSON *) cJSON_CreateFalse(void);
+CJSON_PUBLIC(cJSON *) cJSON_CreateBool(cJSON_bool boolean);
+CJSON_PUBLIC(cJSON *) cJSON_CreateNumber(double num);
+CJSON_PUBLIC(cJSON *) cJSON_CreateString(const char *string);
+/* raw json */
+CJSON_PUBLIC(cJSON *) cJSON_CreateRaw(const char *raw);
+CJSON_PUBLIC(cJSON *) cJSON_CreateArray(void);
+CJSON_PUBLIC(cJSON *) cJSON_CreateObject(void);
+
+/* Create a string where valuestring references a string so
+ * it will not be freed by cJSON_Delete */
+CJSON_PUBLIC(cJSON *) cJSON_CreateStringReference(const char *string);
+/* Create an object/array that only references it's elements so
+ * they will not be freed by cJSON_Delete */
+CJSON_PUBLIC(cJSON *) cJSON_CreateObjectReference(const cJSON *child);
+CJSON_PUBLIC(cJSON *) cJSON_CreateArrayReference(const cJSON *child);
+
+/* These utilities create an Array of count items.
+ * The parameter count cannot be greater than the number of elements in the number array, otherwise array access will be out of bounds.*/
+CJSON_PUBLIC(cJSON *) cJSON_CreateIntArray(const int *numbers, int count);
+CJSON_PUBLIC(cJSON *) cJSON_CreateFloatArray(const float *numbers, int count);
+CJSON_PUBLIC(cJSON *) cJSON_CreateDoubleArray(const double *numbers, int count);
+CJSON_PUBLIC(cJSON *) cJSON_CreateStringArray(const char *const *strings, int count);
+
+/* Append item to the specified array/object. */
+CJSON_PUBLIC(cJSON_bool) cJSON_AddItemToArray(cJSON *array, cJSON *item);
+CJSON_PUBLIC(cJSON_bool) cJSON_AddItemToObject(cJSON *object, const char *string, cJSON *item);
+/* Use this when string is definitely const (i.e. a literal, or as good as), and will definitely survive the cJSON object.
+ * WARNING: When this function was used, make sure to always check that (item->type & cJSON_StringIsConst) is zero before
+ * writing to `item->string` */
+CJSON_PUBLIC(cJSON_bool) cJSON_AddItemToObjectCS(cJSON *object, const char *string, cJSON *item);
+/* Append reference to item to the specified array/object. Use this when you want to add an existing cJSON to a new cJSON, but don't want to corrupt your existing cJSON. */
+CJSON_PUBLIC(cJSON_bool) cJSON_AddItemReferenceToArray(cJSON *array, cJSON *item);
+CJSON_PUBLIC(cJSON_bool) cJSON_AddItemReferenceToObject(cJSON *object, const char *string, cJSON *item);
+
+/* Remove/Detach items from Arrays/Objects. */
+CJSON_PUBLIC(cJSON *) cJSON_DetachItemViaPointer(cJSON *parent, cJSON * const item);
+CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromArray(cJSON *array, int which);
+CJSON_PUBLIC(void) cJSON_DeleteItemFromArray(cJSON *array, int which);
+CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromObject(cJSON *object, const char *string);
+CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromObjectCaseSensitive(cJSON *object, const char *string);
+CJSON_PUBLIC(void) cJSON_DeleteItemFromObject(cJSON *object, const char *string);
+CJSON_PUBLIC(void) cJSON_DeleteItemFromObjectCaseSensitive(cJSON *object, const char *string);
+
+/* Update array items. */
+CJSON_PUBLIC(cJSON_bool) cJSON_InsertItemInArray(cJSON *array, int which, cJSON *newitem); /* Shifts pre-existing items to the right. */
+CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemViaPointer(cJSON * const parent, cJSON * const item, cJSON * replacement);
+CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemInArray(cJSON *array, int which, cJSON *newitem);
+CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemInObject(cJSON *object,const char *string,cJSON *newitem);
+CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemInObjectCaseSensitive(cJSON *object,const char *string,cJSON *newitem);
+
+/* Duplicate a cJSON item */
+CJSON_PUBLIC(cJSON *) cJSON_Duplicate(const cJSON *item, cJSON_bool recurse);
+/* Duplicate will create a new, identical cJSON item to the one you pass, in new memory that will
+ * need to be released. With recurse!=0, it will duplicate any children connected to the item.
+ * The item->next and ->prev pointers are always zero on return from Duplicate. */
+/* Recursively compare two cJSON items for equality. If either a or b is NULL or invalid, they will be considered unequal.
+ * case_sensitive determines if object keys are treated case sensitive (1) or case insensitive (0) */
+CJSON_PUBLIC(cJSON_bool) cJSON_Compare(const cJSON * const a, const cJSON * const b, const cJSON_bool case_sensitive);
+
+/* Minify a strings, remove blank characters(such as ' ', '\t', '\r', '\n') from strings.
+ * The input pointer json cannot point to a read-only address area, such as a string constant, 
+ * but should point to a readable and writable address area. */
+CJSON_PUBLIC(void) cJSON_Minify(char *json);
+
+/* Helper functions for creating and adding items to an object at the same time.
+ * They return the added item or NULL on failure. */
+CJSON_PUBLIC(cJSON*) cJSON_AddNullToObject(cJSON * const object, const char * const name);
+CJSON_PUBLIC(cJSON*) cJSON_AddTrueToObject(cJSON * const object, const char * const name);
+CJSON_PUBLIC(cJSON*) cJSON_AddFalseToObject(cJSON * const object, const char * const name);
+CJSON_PUBLIC(cJSON*) cJSON_AddBoolToObject(cJSON * const object, const char * const name, const cJSON_bool boolean);
+CJSON_PUBLIC(cJSON*) cJSON_AddNumberToObject(cJSON * const object, const char * const name, const double number);
+CJSON_PUBLIC(cJSON*) cJSON_AddStringToObject(cJSON * const object, const char * const name, const char * const string);
+CJSON_PUBLIC(cJSON*) cJSON_AddRawToObject(cJSON * const object, const char * const name, const char * const raw);
+CJSON_PUBLIC(cJSON*) cJSON_AddObjectToObject(cJSON * const object, const char * const name);
+CJSON_PUBLIC(cJSON*) cJSON_AddArrayToObject(cJSON * const object, const char * const name);
+
+/* When assigning an integer value, it needs to be propagated to valuedouble too. */
+#define cJSON_SetIntValue(object, number) ((object) ? (object)->valueint = (object)->valuedouble = (number) : (number))
+/* helper for the cJSON_SetNumberValue macro */
+CJSON_PUBLIC(double) cJSON_SetNumberHelper(cJSON *object, double number);
+#define cJSON_SetNumberValue(object, number) ((object != NULL) ? cJSON_SetNumberHelper(object, (double)number) : (number))
+/* Change the valuestring of a cJSON_String object, only takes effect when type of object is cJSON_String */
+CJSON_PUBLIC(char*) cJSON_SetValuestring(cJSON *object, const char *valuestring);
+
+/* If the object is not a boolean type this does nothing and returns cJSON_Invalid else it returns the new type*/
+#define cJSON_SetBoolValue(object, boolValue) ( \
+    (object != NULL && ((object)->type & (cJSON_False|cJSON_True))) ? \
+    (object)->type=((object)->type &(~(cJSON_False|cJSON_True)))|((boolValue)?cJSON_True:cJSON_False) : \
+    cJSON_Invalid\
+)
+
+/* Macro for iterating over an array or object */
+#define cJSON_ArrayForEach(element, array) for(element = (array != NULL) ? (array)->child : NULL; element != NULL; element = element->next)
+
+/* malloc/free objects using the malloc/free functions that have been set with cJSON_InitHooks */
+CJSON_PUBLIC(void *) cJSON_malloc(size_t size);
+CJSON_PUBLIC(void) cJSON_free(void *object);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

c/network/erroprocess/erroprocess.c

@@ -0,0 +1,16 @@
+#include "erroprocess.h"
+#include <stdio.h>
+#include <stddef.h>
+
+int give_upjobs(indiector *self)
+{
+    if(self == NULL)
+    {
+        return -1;
+    }
+}
+
+int init_indector(indiector *self)
+{
+    
+}

c/network/erroprocess/erroprocess.h

@@ -0,0 +1,24 @@
+#ifndef ERROPROCESS
+#define ERROPROCESS
+
+
+#define BASE_INDIECTOR 2
+#define MAX_index 5
+#define CIR_TIME 20
+typedef struct jobs
+{
+    struct jobs* next;
+    int job;
+}jobs;
+
+
+typedef struct indiector
+{
+    int status;//熔断标志位
+    int retreat_index;//退避指数
+    jobs *head_job;
+    jobs *rear_job;
+    int (*give_upjobs)(struct indiector *);
+}indiector;
+
+#endif

c/network/http/http_rel.c

@@ -0,0 +1,80 @@
+#include <stddef.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <stdio.h>
+
+#include "http_rel.h"
+
+const char *http_get_body(const char *buf)
+{
+    if (!buf) return NULL;
+
+    /* 找到 header 与 body 之间的空行 "\r\n\r\n" */
+    const char *sep = strstr(buf, "\r\n\r\n");
+    if (!sep) return NULL;          /* 格式错误 */
+
+    const char *body = sep + 4;     /* 跳过 "\r\n\r\n" */
+
+    /* 简单判断：如果后面还有数据，就认为是 body */
+    if (*body == '\0') return NULL; /* 没有 body */
+
+    return body;
+}
+
+
+/* 一次性读完一个 HTTP 请求，返回 malloc 得到的完整字符串（含头+体），调用者 free。
+   返回 NULL 表示读取出错或内存不足。
+*/
+char *recv_http_request(int cfd)
+{
+    char  head[8192];
+    int   body_len = 0;
+
+    /* 1. 读头部到 \r\n\r\n */
+    size_t n = 0;
+    while (n < sizeof(head)) {
+        if (read(cfd, head + n, 1) != 1) goto err;
+        if (n >= 3 && memcmp(head + n - 3, "\r\n\r", 3) == 0) {
+            if (read(cfd, head + n, 1) != 1) goto err;   /* 再吃一个 \n */
+            ++n;
+            break;
+        }
+        ++n;
+    }
+    head[n] = 0;
+
+    /* 2. 解析 Content-Length */
+    const char *p = head;
+    while ((p = strchr(p, '\n')) != NULL) {
+        if (sscanf(p, "\nContent-Length: %d", &body_len) == 1) break;
+        ++p;
+    }
+
+    /* 3. 读 body */
+    char *body = NULL;
+    if (body_len > 0) {
+        body = malloc(body_len + 1);
+        if (!body) goto err;
+        size_t got = 0;
+        while (got < (size_t)body_len) {
+            ssize_t rd = read(cfd, body + got, body_len - got);
+            if (rd <= 0) { free(body); goto err; }
+            got += rd;
+        }
+        body[got] = 0;
+    }
+
+    /* 4. 拼成完整字符串 */
+    char *full = malloc(n + (body_len ? body_len : 0) + 1);
+    if (!full) { free(body); goto err; }
+    memcpy(full, head, n);
+    if (body_len) memcpy(full + n, body, body_len);
+    full[n + body_len] = 0;
+    free(body);
+    return full;
+
+err:
+    return NULL;
+}
+

c/network/http/http_rel.h

@@ -0,0 +1,7 @@
+#ifndef HTTP_REL
+#define HTTP_REL
+
+const char *http_get_body(const char *buf);
+char *recv_http_request(int cfd);
+
+#endif

c/network/network.c

@@ -0,0 +1,296 @@
+#define _GNU_SOURCE 
+
+#include "network.h"
+#include "swap.h"
+#include "http/http_rel.h"
+#include "cJSON.h"
+#include "tools/log/log.h"
+#include "tools/quit/quit.h"
+#include "erroprocess/erroprocess.h"
+#include <semaphore.h>
+#include <unistd.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <fcntl.h>
+#include <string.h>
+#include <stddef.h>
+#include <errno.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <sys/epoll.h>
+
+static void safe_strcpy(char *dst, size_t dst_size, const char *src)
+{
+    if (!src) { dst[0] = '\0'; return; }
+    size_t len = strlen(src);
+    if (len >= dst_size) len = dst_size - 1;
+    memcpy(dst, src, len);
+    dst[len] = '\0';
+}
+
+/* 主解析 */
+int rbt_parse_json(const char *json_text, rbt_msg *out)
+{
+    memset(out, 0, sizeof(*out));          // 统一清 0，gid 天然 '\0'
+
+    cJSON *root = cJSON_Parse(json_text);
+    if (!root) return -1;
+
+    /* 1. 取群号（可能没有） */
+    cJSON *gid = cJSON_GetObjectItemCaseSensitive(root, "group_id");
+    if (cJSON_IsString(gid))
+        safe_strcpy(out->gid, sizeof(out->gid), gid->valuestring);
+    else if (cJSON_IsNumber(gid))          // 有些框架是数字
+        snprintf(out->gid, sizeof(out->gid), "%d", gid->valueint);
+
+    /* 2. 用户号 */
+    cJSON *uid = cJSON_GetObjectItemCaseSensitive(root, "user_id");
+    if (cJSON_IsString(uid))
+        safe_strcpy(out->uid, sizeof(out->uid), uid->valuestring);
+    else if (cJSON_IsNumber(uid))
+        snprintf(out->uid, sizeof(out->uid), "%d", uid->valueint);
+
+    /* 3. 昵称在 sender 对象里 */
+    cJSON *sender = cJSON_GetObjectItemCaseSensitive(root, "sender");
+    if (cJSON_IsObject(sender)) {
+        cJSON *nick = cJSON_GetObjectItemCaseSensitive(sender, "nickname");
+        safe_strcpy(out->nickname, sizeof(out->nickname),
+                    cJSON_IsString(nick) ? nick->valuestring : NULL);
+    }
+
+    /* 4. 原始消息 */
+    cJSON *raw = cJSON_GetObjectItemCaseSensitive(root, "raw_message");
+    safe_strcpy(out->raw_message, sizeof(out->raw_message),
+                cJSON_IsString(raw) ? raw->valuestring : NULL);
+
+    /* 5. 消息类型 */
+    cJSON *type = cJSON_GetObjectItemCaseSensitive(root, "message_type");
+    if (cJSON_IsString(type)) {
+        if (strcmp(type->valuestring, "group") == 0)
+            out->message_type = 'g';
+        else if (strcmp(type->valuestring, "private") == 0)
+            out->message_type = 'p';
+        /* else 保持 0 */
+    }
+
+    cJSON_Delete(root);
+    return 0;   // 成功
+}
+
+int init_http_network(int port)
+{
+    int fd = socket(AF_INET, SOCK_STREAM, 0);
+    fcntl(fd, F_GETFL);
+    struct sockaddr_in addr = {0};
+    addr.sin_family      = AF_INET;      // 和 socket() 一致
+    addr.sin_port        = htons(port); // 端口号必须网络字节序
+    addr.sin_addr.s_addr = htonl(INADDR_ANY); // 0.0.0.0：本机所有网卡
+    bind(fd, (struct sockaddr *)&addr, sizeof(addr));
+    listen(fd,10);
+    return fd;
+}
+
+ssize_t read_req(int fd, void *buf)
+{
+    // TODO 修改读取任务函数
+    ssize_t n = read(fd, buf, MAX_MESSAGE_BUF);
+    if (n == 0)              /* 写端已关闭，管道永不会再有数据 */
+        return 0;
+    return (n > 0) ? n : -1;
+}
+
+int process_message(char *req,log_manager *logger)
+{
+    //TODO 修改管道命令解析
+    if(req ==NULL )
+        return 0;
+    int fd;
+    char front,rear;
+    sscanf(req,"%s/%d/%s",&rear,&fd,&rear);
+    char *req_buf = recv_http_request(fd);
+    const char *body = http_get_body(req_buf);
+    free(req_buf);
+    rbt_msg message;
+    rbt_parse_json(body,&message);
+    make_swap((void*)&message);
+    logs *log = malloc(sizeof log);
+    if(snprintf(log->log,sizeof(log->log),
+        "%s message %s processd ok\n",message.nickname,message.raw_message)<1024);
+    logger->in_log(log,logger);
+}
+
+int iss_work(netm *self,char *command)
+{
+    int i = self->last_alc+1;
+    //查询空闲线程
+    while(self->pool[i].fifo_fd ==0)
+    {
+        if(i<MAX_POOL)
+            i++;
+        else
+            i=0;
+    }
+    //向空闲线程发送数据
+    write(self->pool[i].fifo_fd[0],command,strlen(command));
+    //设置线程程为working
+    atomic_fetch_sub(&self->pool[i].status,1);
+    self->last_alc = i;
+}
+
+void *pth_module(void *args_p)
+{
+    net_args *argms = (net_args*)args_p;
+    pth_m *pmd = argms->pth;
+    log_manager *logger = argms->log;
+    //参数解析
+    char name[256] = {'\0'};
+    sprintf(name,"chatrebot%lu",pmd->pthread_id);
+    int swap = create_swap(name);
+    //创建共享内存
+    char swap_arg[64] = {'\0'};
+    sprintf(swap_arg,"%d",swap);
+    pid_t id = fork();
+    if(id == 0)
+    {
+        char *args[]={
+            "Pluginmanager",
+            "--swap",swap_arg,
+        NULL};
+        execv("Run_pluhginmanager",args);
+    }
+    logs *pth_log = (logs*)malloc(sizeof(logs));
+    sprintf(pth_log->log,"PID:%lu launched python plugines\n",pmd->pthread_id);
+    
+    logger->in_log(pth_log,logger);
+    //拉起python插件管理器
+    for(;;){
+        //线程池中，单个线程模型
+
+        char req[64];
+        //从管道中读取请求，并解析，无内容时休眠
+        int n = read_req(pmd->fifo_fd[0],req);
+        //管道关闭时退出;
+
+        if (n == EOF) {
+            return NULL;
+            break;
+        }
+        else{
+            process_message(req,logger);
+            atomic_fetch_add(&pmd->status, 1);
+        }
+    }
+}
+
+int start_pool(netm  *self)
+{
+    for(int i = 0;i<MAX_POOL;i++)
+    {
+        //为线程开辟管道
+        pipe(self->pool[i].fifo_fd);
+        //启动线程
+        net_args arg;
+        arg.pth =&self->pool[i];
+        arg.log = self->logmanager;
+        self->pool[i].status = 1;
+        pthread_create(&self->pool[i].pthread_id,NULL,pth_module,(void*)&arg);
+    }
+}
+
+int shutdown_pool(netm *self)
+{
+    for(int i = 0;i<MAX_POOL;i++)
+    {
+        if(self->pool[i].status == -1)
+            continue;
+        self->pool[i].status = -1;
+        close(self->pool[i].fifo_fd[1]);
+    }
+    return 1;
+}
+
+int server_run(int port,int fifo_fd,netm *self)
+{
+    int epfd = epoll_create1(EPOLL_CLOEXEC);   // 推荐
+    if (epfd == -1) {
+        perror("epoll_create1");
+        exit(EXIT_FAILURE);
+    }
+    struct epoll_event ev;
+    //设置epoll同时监听控制管道与http请求
+    ev.events = EPOLLIN;
+    ev.data.fd = fifo_fd;
+    epoll_ctl(epfd, EPOLL_CTL_ADD, fifo_fd, &ev);
+    char iss_buf[256];
+    self->http_fd = init_http_network(port);
+
+    ev.data.fd = self->http_fd;
+    epoll_ctl(epfd, EPOLL_CTL_ADD, self->http_fd, &ev);
+    struct epoll_event events[10];
+    self->epoll_fd = epfd;
+    for(;;)
+    {
+        /*工作循环-----------------------------*/
+        int nf = epoll_wait(epfd,events,10,-1);
+        printf("%d\n",nf);
+        if (nf == -1) { 
+                perror("epoll_wait"); 
+                break; 
+        }
+        for(int i = 0; i<nf;i++){
+
+            if(events[i].data.fd ==self->http_fd)
+            {
+                int nt_fd = accept4(self->http_fd,NULL,NULL,SOCK_NONBLOCK | SOCK_CLOEXEC);
+                printf("%d\n",nt_fd);
+                if(nt_fd == -1)
+                    continue;
+                sprintf(iss_buf,"s/%d/e",nt_fd);
+                self->iss_work(self,iss_buf);
+            }
+            if(events[i].data.fd == fifo_fd)
+            {
+                char command;
+                while(read(fifo_fd,&command,1)==1)
+                {
+                    switch(command){
+                        case 'q':
+                        //退出逻辑
+                            quit_server(self);
+                            return 1;
+                            break;
+                        case 'u':
+                        //插件更新逻辑
+
+                            break;
+                    }
+                }
+            }
+        }
+        /*工作循环----------------------------*/
+    }
+}
+
+void *run_network(void *self_d)
+{
+    netm *self = (netm*)self_d;
+    self->start_pool(self);
+    server_run(self->port,self->fifo_fd[0],self);
+    self->shutdown_pool(self);
+}
+
+int init_networkmanager(netm *self,int *fifo,log_manager *logmanager,int port)
+{
+    self->run_network = run_network;
+    self->iss_work = iss_work;
+    self->start_pool = start_pool;
+    self->shutdown_pool = shutdown_pool;
+    //装载方法
+    self->fifo_fd[0]= fifo[0];
+    self->fifo_fd[1]= fifo[1];
+    self->last_alc = 0;
+    //初始化参数
+    self->logmanager = logmanager;
+    self->err_indictor = (indiector*)malloc(sizeof(indiector));
+    self->port = port;
+}

c/network/network.h

@@ -0,0 +1,53 @@
+#ifndef NETWORK
+#define NETWORK
+
+#define MAX_POOL 10
+#define MAX_MESSAGE_BUF 10240
+#include <pthread.h>
+#include "tools/log/log.h"
+#include "erroprocess/erroprocess.h"
+#include <stdatomic.h>
+//单个线程模型
+typedef struct pthread_module
+{
+    pthread_t pthread_id;
+    int fifo_fd[2];
+    atomic_int status;
+}pth_m;
+
+typedef struct net_args
+{
+    log_manager *log;
+    pth_m *pth;
+}net_args;
+
+typedef struct network_manager
+{
+    void *(*run_network)(void*);
+    int (*start_pool)(struct network_manager*);
+    int (*shutdown_pool)(struct network_manager*);
+    int (*iss_work)(struct network_manager*,char *);
+    pth_m pool[MAX_POOL];
+    int fifo_fd[2];
+    log_manager *logmanager;
+    indiector *err_indictor;
+    int last_alc;
+    int port;
+    int epoll_fd;
+    int http_fd;
+}netm;
+
+typedef struct rebot_message
+{
+    char gid[32];
+    char uid[32];
+    char nickname[64];
+    char raw_message[MAX_MESSAGE_BUF];
+    char message_type;
+    sem_t status;
+    int state;
+}rbt_msg;
+
+int init_networkmanager(netm *self,int *fifo,log_manager *logmanager,int port);
+
+#endif

c/network/swap.c

@@ -0,0 +1,34 @@
+#define _GNU_SOURCE  
+
+#include <stdio.h>
+#include <stddef.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <linux/memfd.h>
+#include <sys/syscall.h>
+#include <sys/mman.h>
+#include "network.h"
+
+int make_swap(void *message)
+{
+    rbt_msg *msg = (rbt_msg*)message;
+            printf("gid=%s uid=%s nick=%s raw=%s type=%c\n",
+               msg->gid, msg->uid, msg->nickname,
+               msg->raw_message, msg->message_type);
+}
+
+int create_swap(const char *name)
+{
+   int fd = memfd_create(name,0);
+   //申请共享内存
+   ftruncate(fd, sizeof(rbt_msg));
+   //调整大小
+   rbt_msg *init_msg = (rbt_msg*)mmap(NULL, sizeof(rbt_msg), PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
+   char buf[MAX_MESSAGE_BUF] = {'\0'};
+   memcpy(init_msg->raw_message,buf,MAX_MESSAGE_BUF);
+   memcpy(init_msg->nickname,buf,64);
+   munmap((void*)init_msg,sizeof(rbt_msg));
+   //初始化
+   return fd;
+}

c/network/swap.h

@@ -0,0 +1,7 @@
+#ifndef SWAP
+#define SWAP
+
+int make_swap(void *);
+int create_swap(const char *name);
+
+#endif

c/run_pluginmanager/run_pluginmanager.c

@@ -0,0 +1,9 @@
+#include <unistd.h>
+
+int main(int argc,char **argv)
+{
+    for(;;)
+    {
+        sleep(10);
+    }
+}

c/tem/ctl.c

@@ -0,0 +1,295 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <stddef.h>
+#include <string.h>
+#include <termios.h>
+#include <pthread.h>
+#include <signal.h>
+
+#include "ctl.h"
+
+#include "interpreter/interpreter.h"
+#include "tools/log/log.h"
+
+static void goto_col(int x)
+{
+    char seq[32];
+    int  n = snprintf(seq, sizeof(seq), "\r\033[%dC", x+1); /* 1-based */
+    write(STDOUT_FILENO, seq, n);
+}
+
+int replace_chars(int start_pos, int old_len, const char *new_str) {
+    // 1. 移动光标到起始位置
+    if(new_str == NULL)
+        return -1;
+    char move_cmd[16];
+    int move_len = snprintf(move_cmd, sizeof(move_cmd), "\033[%dG", start_pos + 1); // ANSI 列从1开始
+    write(STDOUT_FILENO, move_cmd, move_len);
+
+    // 2. 写入新内容
+    int new_len = strlen(new_str);
+    write(STDOUT_FILENO, new_str, new_len-1);
+
+    // 3. 如果新内容比原内容短，删除剩余部分
+    if (new_len < old_len) {
+        write(STDOUT_FILENO, "\033[K", 3);
+    }
+}
+
+int take_history(Ctl *self,int *currant_index,int *length,char *buf,int toward)
+{
+    if(toward ==1)
+    {
+        if(*currant_index>0)
+            (*currant_index)--;
+        else
+            *currant_index = HISTORY_BUF-1;
+
+    }
+    else if(toward == 0)
+    {
+        if(*currant_index <HISTORY_BUF-1)
+            (*currant_index)++;
+        else
+            *currant_index = 0;
+    }
+
+    if(self->history[*currant_index] == NULL){
+        *length = *length-2;
+        return 0;
+    }
+    replace_chars(sizeof(PROMPT)-1,*length,self->history[*currant_index]);
+    memcpy(buf,self->history[*currant_index],MAX_BUF);
+    buf[strlen(buf)-1] = '\0';
+    *length = strlen(buf);
+    return 0;
+}
+
+
+
+int del_char(int length, int index, char *buf)
+{ 
+    int buf_idx = index - sizeof(PROMPT);  // 待删字符在 buf 中的下标
+
+    if (length == index)           // 行尾退格
+    {
+        write(STDOUT_FILENO, "\b \b", 3);
+        return 1;
+    }
+
+    int str_len = length - index;      
+    char *new_str = (char*)malloc(str_len);
+    memcpy(new_str, &buf[buf_idx+2], str_len-1);
+    write(STDOUT_FILENO, new_str, str_len);
+    goto_col(length - 2);
+    write(STDOUT_FILENO, "\033[K", 3);
+    goto_col(index - 1);
+    char *restr = buf+index-sizeof(PROMPT)+1;
+    memcpy(restr,new_str,str_len);
+    free(new_str);
+    return 1;
+}
+
+
+int get_cursor(int *col)
+{
+    int row;
+    struct termios old, tmp;
+    tcgetattr(STDIN_FILENO, &old);
+    tmp = old;
+    cfmakeraw(&tmp);
+    tcsetattr(STDIN_FILENO, TCSADRAIN, &tmp);
+
+    /* 发 DSR 查询：ESC [ 6 n */
+    write(STDOUT_FILENO, "\033[6n", 4);
+
+    /* 读应答，最大 16 字节足够：ESC [ rr ; cc R */
+    char buf[16] = {0};
+    int i = 0;
+    while (i < sizeof(buf) - 1) {
+        read(STDIN_FILENO, &buf[i], 1);
+        if (buf[i] == 'R') break;
+        ++i;
+    }
+    buf[++i] = '\0';
+
+    tcsetattr(STDIN_FILENO, TCSADRAIN, &old);   /* 恢复终端属性 */
+
+    /* 解析 ESC [ row ; col R */
+    if (sscanf(buf, "\033[%d;%dR",&row, col) != 2)
+        return -1;
+    return 0;
+}
+
+int read_line(char *buf,Ctl *self)
+{
+    int length = 0;
+    char input_buf;
+    int cursor_index = 0;
+    int currant_index = self->index;
+    while(read(0,&input_buf,1)==1&&length<MAX_BUF)
+    {
+        switch (input_buf) {
+            case '\n':                    
+                buf[length++] = input_buf;
+                write(STDOUT_FILENO,"\n",1);
+                buf[length] = '\0';
+                return length;
+            
+            //backspace
+            case 0x7F:
+                buf[length] = '\0';
+                if(length == 0)
+                    break;
+                length--;
+                get_cursor(&cursor_index);
+                del_char(length+sizeof(PROMPT),cursor_index-1,buf);
+                break;
+            //方向键
+            case 0x41: case 0x42: case 0x43: case 0x44:
+                if (length >= 2 &&
+                    buf[length - 1] == 0x5B &&
+                    buf[length - 2] == 0x1B)
+                {
+                    switch(input_buf)
+                    {
+                        case 0x41:
+                            take_history(self,&currant_index,&length,buf,1);
+                            break;
+                            //一定记得加break!!!
+                        case 0x42:
+                            take_history(self,&currant_index,&length,buf,0);
+                            break;
+                        case 0x43:
+                            get_cursor(&cursor_index);
+                            length = length-2;
+                            if(cursor_index == sizeof(PROMPT)+length)
+                            {
+                                break;
+                            }
+                            write(STDOUT_FILENO, "\x1b[C", 3);
+                            break;
+                        case 0x44:
+                            get_cursor(&cursor_index);
+                            length = length -2;
+                            if(cursor_index == sizeof(PROMPT))
+                            {
+                                break;
+                            }
+                            write(STDOUT_FILENO, "\x1b[D", 3);
+                            break;
+
+                    }      
+                    break;                
+                }
+            default:                       
+                write(STDOUT_FILENO, &input_buf, 1);
+                buf[length++] = input_buf;
+                cursor_index = length;
+                break;
+            }
+
+    }
+    if(length>=MAX_BUF)
+    {
+        perror("SYS:input pass edge");
+    }
+
+}
+
+int infifo(Ctl *self,const char *cmd)
+{
+    if(self->history[self->index]!=NULL){
+        memcpy(self->history[self->index],cmd,MAX_BUF);
+    }
+    else{
+        self->history[self->index] = (char*)malloc(MAX_BUF*sizeof(char));
+        memcpy(self->history[self->index],cmd,MAX_BUF);
+    }
+    //存储命令历史s
+    if(self->index<HISTORY_BUF){
+        self->index++;
+    }
+    else{
+        self->index = 0;
+    }
+
+}
+
+int free_history(Ctl *self)
+{
+    for(int i = 0;i<6;i++)
+    {
+        if(self->history[i]!=NULL)
+        {
+            free(self->history[i]);
+        }
+    }
+    return 1;
+}
+
+int teml(Ctl *self,int fifo[2])
+{   
+    char input[MAX_BUF] = {'\0'};
+    ctx *command = (ctx*)malloc(sizeof(ctx));
+    Cmd cmd_dir[10];
+    init_interpreter(cmd_dir,command,fifo,self->logmanager);//初始化解释器
+    //创建线程用于定期清理日志
+    pthread_create(&self->logwathcher,NULL,self->logmanager->clear_log,self->logmanager);
+    command->statue = 0;
+    self->command = command;
+    do
+    {   //设置缓冲区，接收用户输入
+        write(STDOUT_FILENO,PROMPT,sizeof(PROMPT));
+        command->line = read_line(input,self);
+        if(command->line == -1)
+            perror("sys error");
+        //将用户输入入队
+        infifo(self,input);
+        logs *log = (logs*)malloc(sizeof(logs));
+        memcpy(log->log,input,sizeof(input));
+        self->logmanager->in_log(log,self->logmanager);
+        memcpy(command->command,input,sizeof(input));        
+        interpret(SIG_MOD,command,cmd_dir);
+        const char fexp[256] = {'\0'};
+        memcpy(&input,&fexp,MAX_BUF);
+    }while(command->statue == 0);
+    log_manager_stop(self->logmanager);
+    pthread_join(self->logwathcher,NULL);
+    //关闭log定期清理程序
+    close(fifo[0]);
+
+    close(fifo[1]);
+    free_history(self);
+    self->command = NULL;
+    free(command);
+}
+
+Ctl *init_tem(log_manager *logmanager)
+{
+    //初始化终端对象
+    Ctl *tem = (Ctl*)malloc(sizeof(Ctl));
+    tem->run = teml;
+    tem->infifo = infifo;
+    tem->index = 0;
+    tem->logmanager = logmanager;
+    char *his_buf[HISTORY_BUF] = {NULL};
+    memcpy(tem->history,his_buf,HISTORY_BUF);
+    for(int i =0;i<6;i++)
+    {
+        tem->history[i] = NULL;
+    }
+    struct termios tio_setting;
+    tcgetattr(STDIN_FILENO,&tio_setting);
+    tio_setting.c_lflag &= ~(ICANON|ECHO);
+    tio_setting.c_cflag |=ISIG;
+    tio_setting.c_cc[VMIN] =1;
+    tio_setting.c_cc[VTIME] = 0;
+    tcsetattr(STDERR_FILENO,TCSAFLUSH,&tio_setting);
+
+    return tem;
+}
+
+

c/tem/ctl.h

@@ -0,0 +1,30 @@
+#ifndef CTL
+#define CTL
+
+#include <pthread.h>
+#include "tools/toml/toml.h"
+#include "tools/log/log.h"
+#include "interpreter/interpreter.h"
+
+#define MAX_BUF 256
+#define HISTORY_BUF 210
+#define PROMPT "chatbot$$ "
+
+
+typedef struct Ctl
+{
+    int (*run)(struct Ctl*,int *);
+    int (*infifo)(struct Ctl*,const char*);
+    int index;
+    char *history[HISTORY_BUF];
+    pthread_t logwathcher;
+    log_manager *logmanager;
+    ctx *command;//解释器上下文
+    toml_table_t *config;
+}Ctl;
+
+Ctl *init_tem(log_manager *logmanager);
+int free_history(Ctl *self);
+
+
+#endif

c/tools/log/log.c

@@ -0,0 +1,153 @@
+#define _POSIX_C_SOURCE 200112L
+#include "log.h"
+#include <stdio.h>
+#include <stddef.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <time.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <string.h>
+
+int in_log(logs *log,log_manager *self)
+{
+    sem_wait(&self->log_sem);//加锁
+    logs *buf = self->rear;
+    if(self->log == NULL){
+        self->log = log;
+        self->rear = log;
+        self->count++;
+        sem_post(&self->log_sem);
+        return 0;
+    }
+    self->count++;
+    buf->next = log;
+    log->next = NULL;
+    self->rear = log;
+    sem_post(&self->log_sem);
+    return self->count;
+}
+
+logs *out_log(log_manager *self)
+{
+    sem_wait(&self->log_sem);
+    logs *buf = self->log;
+    if(self->log==NULL)
+    {
+        sem_post(&self->log_sem);
+        return NULL;
+    }
+    if(self->log->next ==NULL)
+        self->log = self->rear = NULL;
+    self->count--;
+    sem_post(&self->log_sem);
+    buf->next =NULL;
+    return buf;
+}
+
+int sleep_with_signal(log_manager *self)
+{
+    struct timespec ts;
+    int rc;
+
+    /* 计算绝对超时：当前 + 1000 s */
+    if (clock_gettime(CLOCK_MONOTONIC, &ts) != 0)
+        return -1;                     /* 罕见失败 */
+
+    ts.tv_sec += 1000;
+    /* 纳秒部分无需处理，1000 s 整不会溢出 */
+
+    pthread_mutex_lock(&self->mtx);    /* 进入临界区 */
+
+    while (1) {
+        rc = pthread_cond_timedwait(&self->cond, &self->mtx, &ts);
+        if (rc == ETIMEDOUT) {         /* 1000 s 到点 */
+            pthread_mutex_unlock(&self->mtx);
+            return 1;                  /* 正常超时 */
+        }
+        if (rc != 0) {                 /* 其他错误 */
+            pthread_mutex_unlock(&self->mtx);
+            return -1;
+        }
+
+        /* 被 signal / broadcast 提前唤醒，检查 stop */
+        if (self->stop == 1) {/* 主线程要求退出 */
+            pthread_mutex_unlock(&self->mtx);
+            return 0;                  /* 告诉调用者：该结束了 */
+        }
+    }
+}
+
+int cleanup(log_manager *self)
+{
+    if(self->log ==NULL)
+        return 1;
+    logs *tobeclean,*loc;
+    sem_wait(&self->log_sem);//获取信号量
+    loc = self->log;
+    self->log = NULL;
+    self->count = 0;//摘取log链
+    sem_post(&self->log_sem);
+    //释放信号量
+    while(loc->next !=NULL)
+    {
+        tobeclean = loc;
+        loc = loc->next;
+        int fd = open("log.txt",O_CREAT | O_WRONLY | O_APPEND, 0777);
+        if(fd == -1)
+            perror("file:");
+        write(fd,loc->log,strlen(loc->log));
+        close(fd);
+        free(tobeclean);
+    }
+    free(loc);
+}
+
+void log_manager_stop(log_manager *self)
+{
+    pthread_mutex_lock(&self->mtx);
+    self->stop = 1;                /* 置退出标志 */
+    pthread_cond_broadcast(&self->cond); /* 唤醒所有等待线程 */
+    printf("SYS:stopping loger\n");
+    pthread_mutex_unlock(&self->mtx);
+    printf("SYS:done\n");
+}
+
+//定期清理函数
+void *clear_log(void *self_p)
+{
+    log_manager *self = (log_manager*)self_p;
+    for(;;)
+    {
+        sleep_with_signal(self);
+        sem_wait(&self->log_sem);
+        if((self->count<256||self->log==NULL)&&self->stop !=1){
+            sem_post(&self->log_sem);
+            continue;
+        }
+        sem_post(&self->log_sem);
+        cleanup(self);
+        if(self->stop == 1){
+            return NULL;
+        }
+    }
+}
+
+int init_loger(log_manager *self)
+{
+    if(self == NULL)
+    {
+        perror("NULL\n");
+        return -1;
+    }
+    sem_init(&self->log_sem, 0,1);
+    pthread_mutex_init(&self->mtx,NULL);
+    pthread_cond_init(&self->cond,NULL);
+    self->in_log = in_log;
+    self->out_log = out_log;
+    self->clear_log = clear_log;
+    self->log = NULL;
+    self->stop =  0;
+    self->cleanup = cleanup;
+    self->count = 0;
+}

c/tools/log/log.h

@@ -0,0 +1,33 @@
+#ifndef LOG
+#define LOG
+
+#include <semaphore.h>
+#include <pthread.h>
+
+#define MAX_LOG 256
+
+typedef struct logs
+{
+    char log[1024];
+    struct logs *next;
+}logs;
+
+typedef struct log_manager
+{
+    int (*in_log)(logs *,struct log_manager*);
+    logs* (*out_log)(struct log_manager*);
+    void *(*clear_log)(void*);
+    int (*cleanup)(struct log_manager*);
+    sem_t log_sem;
+    logs *log;
+    logs *rear;
+    int count;
+    pthread_mutex_t mtx;
+    pthread_cond_t cond;
+    int stop;
+}log_manager;
+
+void log_manager_stop(log_manager *self);
+int init_loger(log_manager *self);
+
+#endif

c/tools/pkgmanager/pkginstall.c

@@ -0,0 +1,40 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include "pkginstall.h"
+
+int check_python(pkger *self)
+{
+    //只需要检查pip是否存在，即可确定python是否存在
+    int pip_ex = system("pip -V >/dev/null 2>&1");
+    if(WIFEXITED(pip_ex) && WEXITSTATUS(pip_ex) == 0)
+        return 1;
+    else
+        return 0;
+}
+
+
+//TO_DO 完成一下函数实现
+
+int install_dependence(pkger *self)
+{
+
+}
+
+int check_dir(pkger *self)
+{
+    
+}
+
+int packup(pkger *self)
+{
+
+}//运行包安装器时执行此函数，注意所有函数通过结构体内部调用。
+
+pkger *init_pkginstaller()
+{
+    pkger *self = (pkger*)malloc(sizeof(pkger));
+    self->check_dir = check_dir;
+    self->check_python = check_python;
+    self->install_dependence = install_dependence;
+    self->packup = packup;
+}

c/tools/pkgmanager/pkginstall.h

@@ -0,0 +1,21 @@
+#ifndef PKGINSTALL
+
+#define PKGINSTALL
+
+typedef struct pkger
+{
+    //data
+    int requirement;//存储requirement.txt的文件fd
+    char dir[256];
+    //method
+    int (*check_python)(struct pkger*);
+    int (*install_dependence)(struct pkger*);
+    int (*check_dir)(struct pkger*);
+    int (*packup)(struct pkger*);
+
+}pkger;
+
+pkger *init_pkginstaller();
+
+
+#endif

c/tools/quit/quit.c

@@ -0,0 +1,79 @@
+#define _GNU_SOURCE 
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include<unistd.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <sys/epoll.h>
+#include "quit.h"
+#include "tem/ctl.h"
+#include "tools/toml/toml.h"
+
+int quit_server(netm *self)
+{
+    if(self ==NULL)
+        return -1;
+    if(self->epoll_fd != -1)
+    {
+        epoll_ctl(self->epoll_fd,EPOLL_CTL_DEL,self->http_fd,NULL);
+        epoll_ctl(self->epoll_fd,EPOLL_CTL_DEL,self->fifo_fd[0],NULL);
+        self->epoll_fd = -1;
+    }
+    //关闭epoll监听
+    if(self->http_fd != -1)
+    {
+        close(self->http_fd);
+        self->http_fd =-1;
+    }
+    //关闭socket监听
+    if(self->fifo_fd[0] != -1)
+    {
+        close(self->fifo_fd[0]);
+        self->fifo_fd[0] = -1;
+    }
+    //关闭管道监听
+    
+}
+
+void quit_all(int status,void *self_p)
+{
+    alres *resouce =(alres*)self_p;
+    //转换参数
+
+    resouce->network->shutdown_pool(resouce->network);
+    logs *netlog = (logs*)malloc(sizeof(logs));
+    netlog->next = NULL;
+    memcpy(netlog->log,"shuting down networkserver",27);
+    quit_server(resouce->network);
+    resouce->loger->in_log(netlog,resouce->loger);
+    free(resouce->network);
+    //释放网络资源
+    if(resouce->tem->command !=NULL){
+        free_history(resouce->tem);
+        if(resouce->tem->command->arg != NULL)
+        {
+            args* arg  = resouce->tem->command->arg;
+            if(arg->next !=NULL)
+            {
+                while(arg->next != NULL){
+                args* tobefree = arg;
+                arg = arg->next;
+                free(tobefree);
+                }
+                free(arg);
+            }
+        }
+        toml_free(resouce->tem->config);
+        free(resouce->tem->command);
+    }
+    //释放终端资源
+    pthread_mutex_destroy(&resouce->loger->mtx);
+    resouce->loger->cleanup(resouce->loger);
+    sem_destroy(&resouce->loger->log_sem);
+    //销毁信号量
+
+    free(resouce->loger);
+    //清理日志
+}

c/tools/quit/quit.h

@@ -0,0 +1,20 @@
+#ifndef QUIT_LIB
+#define QUIT_LIB
+
+#include "network/network.h"
+#include "tem/ctl.h"
+#include "tools/log/log.h"
+typedef struct all_resources
+{
+    Ctl *tem;
+    netm *network;
+    log_manager *loger;
+
+}alres;
+
+
+void quit_all(int status,void *self_p);
+int quit_server(netm *self);
+
+
+#endif

c/tools/toml/toml.h

@@ -0,0 +1,175 @@
+/*
+  MIT License
+
+  Copyright (c) CK Tan
+  https://github.com/cktan/tomlc99
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all
+  copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+*/
+#ifndef TOML_H
+#define TOML_H
+
+#ifdef _MSC_VER
+#pragma warning(disable : 4996)
+#endif
+
+#include <stdint.h>
+#include <stdio.h>
+
+#ifdef __cplusplus
+#define TOML_EXTERN extern "C"
+#else
+#define TOML_EXTERN extern
+#endif
+
+typedef struct toml_timestamp_t toml_timestamp_t;
+typedef struct toml_table_t toml_table_t;
+typedef struct toml_array_t toml_array_t;
+typedef struct toml_datum_t toml_datum_t;
+
+/* Parse a file. Return a table on success, or 0 otherwise.
+ * Caller must toml_free(the-return-value) after use.
+ */
+TOML_EXTERN toml_table_t *toml_parse_file(FILE *fp, char *errbuf, int errbufsz);
+
+/* Parse a string containing the full config.
+ * Return a table on success, or 0 otherwise.
+ * Caller must toml_free(the-return-value) after use.
+ */
+TOML_EXTERN toml_table_t *toml_parse(char *conf, /* NUL terminated, please. */
+                                     char *errbuf, int errbufsz);
+
+/* Free the table returned by toml_parse() or toml_parse_file(). Once
+ * this function is called, any handles accessed through this tab
+ * directly or indirectly are no longer valid.
+ */
+TOML_EXTERN void toml_free(toml_table_t *tab);
+
+/* Timestamp types. The year, month, day, hour, minute, second, z
+ * fields may be NULL if they are not relevant. e.g. In a DATE
+ * type, the hour, minute, second and z fields will be NULLs.
+ */
+struct toml_timestamp_t {
+  struct { /* internal. do not use. */
+    int year, month, day;
+    int hour, minute, second, millisec;
+    char z[10];
+  } __buffer;
+  int *year, *month, *day;
+  int *hour, *minute, *second, *millisec;
+  char *z;
+};
+
+/*-----------------------------------------------------------------
+ *  Enhanced access methods
+ */
+struct toml_datum_t {
+  int ok;
+  union {
+    toml_timestamp_t *ts; /* ts must be freed after use */
+    char *s;              /* string value. s must be freed after use */
+    int b;                /* bool value */
+    int64_t i;            /* int value */
+    double d;             /* double value */
+  } u;
+};
+
+/* on arrays: */
+/* ... retrieve size of array. */
+TOML_EXTERN int toml_array_nelem(const toml_array_t *arr);
+/* ... retrieve values using index. */
+TOML_EXTERN toml_datum_t toml_string_at(const toml_array_t *arr, int idx);
+TOML_EXTERN toml_datum_t toml_bool_at(const toml_array_t *arr, int idx);
+TOML_EXTERN toml_datum_t toml_int_at(const toml_array_t *arr, int idx);
+TOML_EXTERN toml_datum_t toml_double_at(const toml_array_t *arr, int idx);
+TOML_EXTERN toml_datum_t toml_timestamp_at(const toml_array_t *arr, int idx);
+/* ... retrieve array or table using index. */
+TOML_EXTERN toml_array_t *toml_array_at(const toml_array_t *arr, int idx);
+TOML_EXTERN toml_table_t *toml_table_at(const toml_array_t *arr, int idx);
+
+/* on tables: */
+/* ... retrieve the key in table at keyidx. Return 0 if out of range. */
+TOML_EXTERN const char *toml_key_in(const toml_table_t *tab, int keyidx);
+/* ... returns 1 if key exists in tab, 0 otherwise */
+TOML_EXTERN int toml_key_exists(const toml_table_t *tab, const char *key);
+/* ... retrieve values using key. */
+TOML_EXTERN toml_datum_t toml_string_in(const toml_table_t *arr,
+                                        const char *key);
+TOML_EXTERN toml_datum_t toml_bool_in(const toml_table_t *arr, const char *key);
+TOML_EXTERN toml_datum_t toml_int_in(const toml_table_t *arr, const char *key);
+TOML_EXTERN toml_datum_t toml_double_in(const toml_table_t *arr,
+                                        const char *key);
+TOML_EXTERN toml_datum_t toml_timestamp_in(const toml_table_t *arr,
+                                           const char *key);
+/* .. retrieve array or table using key. */
+TOML_EXTERN toml_array_t *toml_array_in(const toml_table_t *tab,
+                                        const char *key);
+TOML_EXTERN toml_table_t *toml_table_in(const toml_table_t *tab,
+                                        const char *key);
+
+/*-----------------------------------------------------------------
+ * lesser used
+ */
+/* Return the array kind: 't'able, 'a'rray, 'v'alue, 'm'ixed */
+TOML_EXTERN char toml_array_kind(const toml_array_t *arr);
+
+/* For array kind 'v'alue, return the type of values
+   i:int, d:double, b:bool, s:string, t:time, D:date, T:timestamp, 'm'ixed
+   0 if unknown
+*/
+TOML_EXTERN char toml_array_type(const toml_array_t *arr);
+
+/* Return the key of an array */
+TOML_EXTERN const char *toml_array_key(const toml_array_t *arr);
+
+/* Return the number of key-values in a table */
+TOML_EXTERN int toml_table_nkval(const toml_table_t *tab);
+
+/* Return the number of arrays in a table */
+TOML_EXTERN int toml_table_narr(const toml_table_t *tab);
+
+/* Return the number of sub-tables in a table */
+TOML_EXTERN int toml_table_ntab(const toml_table_t *tab);
+
+/* Return the key of a table*/
+TOML_EXTERN const char *toml_table_key(const toml_table_t *tab);
+
+/*--------------------------------------------------------------
+ * misc
+ */
+TOML_EXTERN int toml_utf8_to_ucs(const char *orig, int len, int64_t *ret);
+TOML_EXTERN int toml_ucs_to_utf8(int64_t code, char buf[6]);
+TOML_EXTERN void toml_set_memutil(void *(*xxmalloc)(size_t),
+                                  void (*xxfree)(void *));
+
+/*--------------------------------------------------------------
+ *  deprecated
+ */
+/* A raw value, must be processed by toml_rto* before using. */
+typedef const char *toml_raw_t;
+TOML_EXTERN toml_raw_t toml_raw_in(const toml_table_t *tab, const char *key);
+TOML_EXTERN toml_raw_t toml_raw_at(const toml_array_t *arr, int idx);
+TOML_EXTERN int toml_rtos(toml_raw_t s, char **ret);
+TOML_EXTERN int toml_rtob(toml_raw_t s, int *ret);
+TOML_EXTERN int toml_rtoi(toml_raw_t s, int64_t *ret);
+TOML_EXTERN int toml_rtod(toml_raw_t s, double *ret);
+TOML_EXTERN int toml_rtod_ex(toml_raw_t s, double *ret, char *buf, int buflen);
+TOML_EXTERN int toml_rtots(toml_raw_t s, toml_timestamp_t *ret);
+
+#endif /* TOML_H */

requirements.txt

@@ -1,16 +0,0 @@
-blinker==1.9.0
-certifi==2025.8.3
-charset-normalizer==3.4.2
-click==8.2.1
-colorama==0.4.6
-Flask==3.1.1
-idna==3.10
-itsdangerous==2.2.0
-Jinja2==3.1.6
-MarkupSafe==3.0.2
-packaging==25.0
-pkg==0.2
-requests==2.32.4
-toml==0.10.2
-urllib3==2.5.0
-Werkzeug==3.1.3

run.bat

@@ -1,74 +0,0 @@
-@echo off
-
-
-set PROJECT_DIR=%~dp0
-set VENV_DIR=%PROJECT_DIR%.venv
-
-
-if exist "%VENV_DIR%\Scripts\activate.bat" (
-
-    call "%VENV_DIR%\Scripts\activate.bat"
-) else (
-
-    python -m venv "%VENV_DIR%"
-    call "%VENV_DIR%\Scripts\activate.bat"
-    
-    if errorlevel 1 (
-        echo error: fail to create env
-        pause
-        exit /b 1
-    )
-)
-
-
-if "%VIRTUAL_ENV%" == "" (
-    echo error: fail to activate env
-    pause
-    exit /b 1
-)
-
-echo installing dependence...
-
-pip install -r requirements.txt
-if errorlevel 1 (
-    echo error: fail to install dependence
-    pause
-    exit /b 1
-)
-
-pip install waitress
-if errorlevel 1 (
-    echo error: fail to install waitress 
-    pause
-    exit /b 1
-)
-
-
-echo reading port from config...
-for /f "usebackq tokens=*" %%P in (`python -c "from src.file_store_api import ConfigManager; config=ConfigManager().load_config(); print(config.get('app', {}).get('list_port', 25580))"`) do (
-    set PORT=%%P
-)
-
-
-if "%PORT%"=="" (
-    set PORT=25580
-    echo can't read port,use custom port:25580
-) else (
-    echo success read port: %PORT%
-)
-
-
-echo starting rebot_server...
-echo listening at: %PORT%
-
-
-waitress-serve --host=0.0.0.0 --port=%PORT% app:app
-
-
-if errorlevel 1 (
-    echo error,fail to start
-    pause
-    exit /b 1
-)
-
-pause

run.sh

@@ -1,51 +0,0 @@
-#!/bin/bash
-
-PROJECT_DIR=$(cd "$(dirname "$0")"; pwd)
-VENV_DIR="$PROJECT_DIR/.venv"
-FLASK_APP="app:app"
-
-
-echo "Activating virtual environment..."
-
-if [ -f "$VENV_DIR/bin/activate" ]; then
-    source "$VENV_DIR/bin/activate"
-else
-    echo "Creating new virtual environment..."
-    python3 -m venv "$VENV_DIR"
-    source "$VENV_DIR/bin/activate"
-fi
-
-if [ -z "$VIRTUAL_ENV" ]; then
-    echo "Error: Failed to activate virtual environment"
-    exit 1
-fi
-
-echo "Installing dependencies..."
-pip install --upgrade pip
-pip install -r requirements.txt
-pip install gunicorn
-
-echo "Reading port from configuration..."
-
-PORT=$(python3 -c \
-"
-from src.file_store_api import ConfigManager
-try:
-    config = ConfigManager().load_config()
-    port = config.get('app', {}).get('list_port')
-    print(str(port) if port else '')
-except Exception as e:
-    print('ERROR: ' + str(e))
-    exit(1)
-")
-
-if [[ "$PORT" == ERROR:* ]] || [ -z "$PORT" ]; then
-    echo "Failed to get port from config: $PORT"
-    echo "Using default port 25580"
-    PORT=25580
-fi
-
-echo "Starting rebot server..."
-echo "Listening on port: $PORT"
-
-gunicorn -w 4 -b 0.0.0.0:$PORT "$FLASK_APP" --access-logfile - --error-logfile -

src/mainprocess.py

@@ -1,79 +0,0 @@
-import sys
-import src.modules.user_modules as usermod
-from src.modules.plugin_modules import BasePlugin, MessageContext
-import src.file_store_api as file_M
-import src.plugin_manager as plm
-
-manager = plm.PluginManager()
-config = file_M.ConfigManager()
-rebot_id = config.load_config().get("rebot").get("id")
-def process_message(uid: str, gid: str | None, message: str) -> str:
-    # 创建上下文
-    ctx = MessageContext(uid=uid, gid=gid, raw_message=message,id = rebot_id)
-    
-    plugin_manager = manager
-    manager.scan_plugins()
-    # 阶段1: before_load 插件（加载数据前）
-    ctx.phase = "before_load"
-    early_plugins = []
-    for name, plugin_cls in plugin_manager._plugins.items():
-        plugin = plugin_cls(ctx)
-        if hasattr(plugin, 'before_load') and callable(plugin.before_load):
-            early_plugins.append(plugin)
-    
-    for plugin in early_plugins:
-        try:
-            result = plugin.before_load()
-            if result is not None:  # 拦截逻辑
-                return result
-        except Exception as e:
-            print(f"error:Plugin {plugin.__class__.__name__} before_load error: {str(e)}")
-    
-    # 消息加载逻辑
-    if gid is not None:
-        ctx.group.messages = ctx.chat_manager.load_group_messages(ctx.group)
-        ctx.user.messages = ctx.chat_manager.load_user_group_messages(user=ctx.user, group=ctx.group)
-    else:
-        ctx.user.messages = ctx.chat_manager.load_private_messages(ctx.user)
-        
-    # 阶段2: after_load 插件（加载数据后）
-    ctx.phase = "after_load"
-    loaded_plugins = []
-    for name, plugin_cls in plugin_manager._plugins.items():
-        plugin = plugin_cls(ctx)
-        if hasattr(plugin, 'after_load') and callable(plugin.after_load):
-            loaded_plugins.append(plugin)
-    
-    for plugin in loaded_plugins:
-        try:
-            result = plugin.after_load()
-            if result is not None:
-                ctx.response = result
-                break
-        except Exception as e:
-            print(f"error:Plugin {plugin.__class__.__name__} after_load error: {str(e)}")
-    
-    # 消息保存逻辑
-    if gid is not None:
-        ctx.chat_manager.save_group_message(ctx.group, role="user", content=ctx.raw_message, sender_id=ctx.user.user_id)
-    else:
-        ctx.chat_manager.save_private_message(ctx.user, role="user", content=ctx.raw_message)
-
-    # 阶段3: after_save 插件（保存数据后）
-    ctx.phase = "after_save"
-    saved_plugins = []
-    for name, plugin_cls in plugin_manager._plugins.items():
-        plugin = plugin_cls(ctx)
-        if hasattr(plugin, 'after_save') and callable(plugin.after_save):
-            saved_plugins.append(plugin)
-    
-    for plugin in saved_plugins:
-        try:
-            result = plugin.after_save()
-            if result is not None and ctx.response is None:
-                ctx.response = result
-        except Exception as e:
-            print(f"error:Plugin {plugin.__class__.__name__} after_save error: {str(e)}")
-    plugin_manager.cleanup()
-    
-    return ctx.response if ctx.response is not None else "ok"