chatccc 0.2.252 → 0.2.254

package/dist/src/shared-prefix.js

@@ -0,0 +1,16 @@
+export const ABD_PREFIX = "/abd";
+export const ABD_APPEND_PROMPT = "请从第一性原理出发挖掘我的真实需求。你觉得我的需求合理吗？开始实现之前有什么问题要问我的？";
+export const ABD_HELP_LINE = `发送 **${ABD_PREFIX}** 前缀消息，将以第一性原理追问真实需求、合理性和实现前问题`;
+export function applySharedPrefix(text) {
+    if (!text.toLowerCase().startsWith(ABD_PREFIX)) {
+        return { matched: false, text, body: text };
+    }
+    const body = text.slice(ABD_PREFIX.length).replace(/^\s+/, "");
+    const appendix = ["---", ABD_APPEND_PROMPT].join("\n");
+    return {
+        matched: true,
+        prefix: ABD_PREFIX,
+        body,
+        text: body ? [body, appendix].join("\n\n") : appendix,
+    };
+}

package/dist/src/shared.js

@@ -0,0 +1,493 @@
+import { execSync } from "node:child_process";
+import { appendFileSync, existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync, } from "node:fs";
+import { createServer } from "node:http";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { inspect } from "node:util";
+import { WebSocketServer, WebSocket } from "ws";
+import { printServiceDidNotStart } from "./exit-banner.js";
+/** 与 config.LOG_DIR 一致（避免 shared 依赖 config 造成循环引用） */
+const BANNER_LOG_DIR = join(homedir(), ".chatccc", "logs");
+const STARTUP_TRACE_FILE = join(BANNER_LOG_DIR, "startup-trace.log");
+/**
+ * 同步写入启动诊断日志（不依赖 console 劫持与 stream 缓冲）。
+ * 用于单实例清理 / taskkill 等可能导致进程突然退出的场景，便于对照 index-*.log 排查。
+ */
+export function appendStartupTrace(message, extra) {
+    try {
+        mkdirSync(BANNER_LOG_DIR, { recursive: true });
+        const suffix = extra !== undefined && Object.keys(extra).length ? ` ${JSON.stringify(extra)}` : "";
+        appendFileSync(STARTUP_TRACE_FILE, `[${new Date().toISOString()}] pid=${process.pid} ppid=${process.ppid} cwd=${process.cwd()} | ${message}${suffix}\n`, "utf-8");
+    }
+    catch {
+        // 诊断日志自身不得影响主流程
+    }
+}
+// ---------------------------------------------------------------------------
+// 进程树：当前进程及其所有祖先（用于避免 taskkill /T 误杀启动链）
+// ---------------------------------------------------------------------------
+let _cachedAncestorSet;
+/** 自当前 PID 沿父链上溯直到系统进程，包含自身。结果会被缓存，同一进程内多次调用复用。 */
+export function getProcessAncestorPidSet() {
+    if (_cachedAncestorSet)
+        return _cachedAncestorSet;
+    const ancestors = new Set();
+    let cur = process.pid;
+    const maxHops = 48;
+    for (let i = 0; i < maxHops; i++) {
+        ancestors.add(cur);
+        if (cur <= 4)
+            break;
+        let parent;
+        if (process.platform === "win32") {
+            try {
+                const out = execSync(`powershell -NoProfile -Command "(Get-CimInstance Win32_Process -Filter 'ProcessId=${cur}' -ErrorAction SilentlyContinue).ParentProcessId"`, { encoding: "utf8", timeout: 3000, stdio: "pipe", windowsHide: true }).trim();
+                parent = parseInt(out, 10);
+            }
+            catch {
+                parent = undefined;
+            }
+        }
+        else {
+            try {
+                const st = readFileSync(`/proc/${cur}/stat`, "utf8");
+                const rp = st.lastIndexOf(")");
+                const fields = st.slice(rp + 2).trim().split(/\s+/);
+                parent = parseInt(fields[1] ?? "", 10);
+            }
+            catch {
+                parent = undefined;
+            }
+        }
+        if (parent === undefined || Number.isNaN(parent) || parent === cur)
+            break;
+        cur = parent;
+    }
+    _cachedAncestorSet = ancestors;
+    return ancestors;
+}
+// ---------------------------------------------------------------------------
+// 杀死进程
+// ---------------------------------------------------------------------------
+export function killByPid(pid) {
+    const pidNum = typeof pid === "string" ? parseInt(pid, 10) : pid;
+    appendStartupTrace("killByPid: begin", { target: pidNum, self: process.pid, ppid: process.ppid });
+    try {
+        process.kill(pidNum, "SIGTERM");
+    }
+    catch {
+        // 不存在，忽略
+    }
+    let taskkillOut = "";
+    try {
+        taskkillOut = execSync(`taskkill /PID ${pidNum} /F /T`, { encoding: "utf8", stdio: "pipe" });
+    }
+    catch (e) {
+        const err = e;
+        const s = (x) => (typeof x === "string" ? x : x?.toString("utf8") ?? "").trim().slice(0, 500);
+        appendStartupTrace("killByPid: taskkill threw (often 进程不存在)", {
+            target: pidNum,
+            status: err.status,
+            stdout: s(err.stdout),
+            stderr: s(err.stderr),
+        });
+        return;
+    }
+    appendStartupTrace("killByPid: taskkill ok", { target: pidNum, stdout: String(taskkillOut).trim().slice(0, 500) });
+}
+// ---------------------------------------------------------------------------
+// 在绑定中继端口之前：结束占用该端口的 LISTENING/UDP 绑定进程（任意类型，非祖先链）
+// ---------------------------------------------------------------------------
+function collectListeningPidsOnPortWindows(port, netstatOut) {
+    const portToken = `:${port}`;
+    const seen = new Set();
+    const out = [];
+    for (const rawLine of netstatOut.split("\n")) {
+        const line = rawLine.trim();
+        if (!line)
+            continue;
+        const upper = line.toUpperCase();
+        if (upper.startsWith("TCP")) {
+            if (!upper.includes("LISTENING"))
+                continue;
+            if (!line.includes(portToken))
+                continue;
+        }
+        else if (upper.startsWith("UDP")) {
+            if (!line.includes(portToken))
+                continue;
+        }
+        else {
+            continue;
+        }
+        const m = line.match(/(\d+)\s*$/);
+        if (!m)
+            continue;
+        const n = parseInt(m[1], 10);
+        if (Number.isNaN(n) || seen.has(n))
+            continue;
+        seen.add(n);
+        out.push(n);
+    }
+    return out;
+}
+/** 在 createRelayServer 之前调用：清掉本机该端口上仍在监听的旧进程（不杀当前进程树祖先）。
+ *  返回实际 kill 的进程数。 */
+export function freeRelayListenPort(port) {
+    const ancestors = getProcessAncestorPidSet();
+    appendStartupTrace("freeRelayListenPort: begin", {
+        port,
+        ancestorPids: [...ancestors].sort((a, b) => a - b).join(","),
+    });
+    if (process.platform !== "win32") {
+        appendStartupTrace("freeRelayListenPort: skip (non-Windows)", { port });
+        return 0;
+    }
+    let killed = 0;
+    try {
+        const portOut = execSync(`netstat -ano | findstr :${port}`, { encoding: "utf8", windowsHide: true });
+        const pids = collectListeningPidsOnPortWindows(port, portOut);
+        appendStartupTrace("freeRelayListenPort: listening PIDs", { port, pids: pids.join(",") || "(none)" });
+        for (const pidNum of pids) {
+            if (ancestors.has(pidNum))
+                continue;
+            console.log(`[KILL] Free port ${port}: killing LISTENING/UDP holder PID ${pidNum}...`);
+            appendStartupTrace("freeRelayListenPort: killByPid", { port, pid: pidNum });
+            killByPid(pidNum);
+            killed++;
+        }
+    }
+    catch {
+        appendStartupTrace("freeRelayListenPort: netstat/findstr (no rows or error)", { port });
+    }
+    appendStartupTrace("freeRelayListenPort: end", { port, killed });
+    return killed;
+}
+/**
+ * 轮询等待端口释放（Windows 下 taskkill 后端口可能不会立即释放）。
+ * 在 freeRelayListenPort kill 了进程后调用，确认端口真正空闲再 listen。
+ */
+export async function waitForPortFree(port, timeoutMs = 3000) {
+    if (process.platform !== "win32")
+        return;
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        try {
+            const out = execSync(`netstat -ano | findstr :${port}`, { encoding: "utf8", windowsHide: true });
+            const pids = collectListeningPidsOnPortWindows(port, out);
+            if (pids.length === 0)
+                return;
+        }
+        catch {
+            return;
+        }
+        await new Promise((r) => setTimeout(r, 200));
+    }
+}
+// ---------------------------------------------------------------------------
+// 单实例保证：PID 文件互斥（端口占用在 freeRelayListenPort + 监听前处理）
+// ---------------------------------------------------------------------------
+export function cleanupPidFile(pidFile) {
+    try {
+        if (existsSync(pidFile) && readFileSync(pidFile, "utf8").trim() === String(process.pid)) {
+            unlinkSync(pidFile);
+        }
+    }
+    catch { /* ok */ }
+}
+export function ensureSingleInstance(pidFile) {
+    const ancestors = getProcessAncestorPidSet();
+    appendStartupTrace("ensureSingleInstance: begin", { pidFile });
+    if (existsSync(pidFile)) {
+        const oldPid = readFileSync(pidFile, "utf8").trim();
+        const oldPidNum = parseInt(oldPid, 10);
+        if (oldPid && oldPid !== String(process.pid)) {
+            if (!Number.isNaN(oldPidNum) && ancestors.has(oldPidNum)) {
+                appendStartupTrace("ensureSingleInstance: skip killing pid from file (in ancestor chain)", { oldPid });
+            }
+            else {
+                console.log(`[INSTANCE] Killing old PID from file: ${oldPid}...`);
+                appendStartupTrace("ensureSingleInstance: killing pid from file", { oldPid });
+                killByPid(oldPid);
+            }
+        }
+        else {
+            appendStartupTrace("ensureSingleInstance: pid file present, skip self", { oldPid, self: process.pid });
+        }
+    }
+    else {
+        appendStartupTrace("ensureSingleInstance: no pid file yet");
+    }
+    mkdirSync(join(pidFile, ".."), { recursive: true });
+    writeFileSync(pidFile, String(process.pid));
+    console.log(`[INSTANCE] Registered PID ${process.pid}`);
+    appendStartupTrace("ensureSingleInstance: registered", { pid: process.pid });
+    // 进程退出时自动清理 PID 文件；SIGINT/SIGTERM 由各 main() 自行接管
+    process.on("exit", (code) => {
+        appendStartupTrace("process exit handler", { code, pid: process.pid });
+        cleanupPidFile(pidFile);
+    });
+}
+// ---------------------------------------------------------------------------
+// 崩溃黑匣子：进程级别异常 / 信号 / beforeExit 同步落盘
+// ---------------------------------------------------------------------------
+//
+// 设计要点：
+// 1) 全部经由 appendStartupTrace（appendFileSync 同步写盘），保证进程立即退出
+//    时也能落盘。console.error 走的是 createWriteStream 异步缓冲，会丢日志。
+// 2) 默认 onFatal 会主动 process.exit(1)。在 Node 20+ 注册了 unhandledRejection
+//    handler 后，默认不再致命退出，会让进程卡在 broken state——主动 exit 让
+//    现象更直观，方便重启与诊断。
+// 3) handler 实现拆成 buildCrashLoggingHandlers（纯函数，无副作用，便于单测）
+//    和 installCrashLogging（把 handler 挂到 process 上，返回 cleanup）。
+const FATAL_STACK_MAX = 4000;
+function coerceError(reason) {
+    if (reason instanceof Error)
+        return reason;
+    if (typeof reason === "string")
+        return new Error(reason);
+    if (reason === undefined)
+        return new Error("unhandled rejection with reason=undefined");
+    if (reason === null)
+        return new Error("unhandled rejection with reason=null");
+    try {
+        return new Error(JSON.stringify(reason));
+    }
+    catch {
+        return new Error(String(reason));
+    }
+}
+function truncateStack(stack) {
+    if (!stack)
+        return "";
+    return stack.length > FATAL_STACK_MAX
+        ? `${stack.slice(0, FATAL_STACK_MAX)}...(truncated)`
+        : stack;
+}
+function safeCall(fn, ...args) {
+    if (!fn)
+        return;
+    try {
+        fn(...args);
+    }
+    catch { /* swallow: 诊断路径不允许二次抛错 */ }
+}
+export function buildCrashLoggingHandlers(opts = {}) {
+    const tracer = opts.tracer ?? appendStartupTrace;
+    const flush = opts.flush;
+    const onFatal = opts.onFatal ?? ((kind, err) => {
+        try {
+            // 这里仍然走 console.error，是为了让终端 / 文件日志都看得见；但同步 trace 是主线
+            console.error(`[FATAL] ${kind}: ${err.message}\n${err.stack ?? ""}`);
+        }
+        catch { /* ignore */ }
+        process.exit(1);
+    });
+    const onSignal = opts.onSignal;
+    const onBeforeExit = opts.onBeforeExit;
+    const handleFatal = (kind, reason) => {
+        const err = coerceError(reason);
+        safeCall(tracer, `FATAL ${kind}`, {
+            message: err.message,
+            stack: truncateStack(err.stack),
+        });
+        safeCall(flush);
+        onFatal(kind, err);
+    };
+    return {
+        uncaughtException: (err) => handleFatal("uncaughtException", err),
+        unhandledRejection: (reason) => handleFatal("unhandledRejection", reason),
+        signalLogger: (sig) => {
+            safeCall(tracer, "signal received", { signal: sig });
+            safeCall(flush);
+            safeCall(onSignal, sig);
+        },
+        beforeExit: (code) => {
+            safeCall(tracer, "beforeExit", { code });
+            safeCall(onBeforeExit, code);
+        },
+    };
+}
+export function installEpipeGuard(streams = [process.stdout, process.stderr], options = {}) {
+    const tracer = options.tracer ?? appendStartupTrace;
+    const onError = (err) => {
+        safeCall(tracer, "stdio write error (non-fatal)", {
+            code: err.code ?? "",
+            message: (err.message ?? String(err)).slice(0, 200),
+        });
+    };
+    for (const stream of streams)
+        stream.on("error", onError);
+    return () => {
+        for (const stream of streams)
+            stream.off("error", onError);
+    };
+}
+/**
+ * 把崩溃黑匣子 handler 装到 process 上，返回 cleanup。
+ *
+ * 注意：本函数只负责 trace + 默认 fatal 退出，**不**接管原有 SIGINT/SIGTERM 清理逻辑
+ * （如 relayServer.close）。让调用方在 installCrashLogging 之后再 process.on('SIGINT', ...)
+ * 注册自己的清理动作即可——Node EventEmitter 会按注册顺序调用所有 listener，trace 同步
+ * 写盘后再走清理，结果稳定。
+ */
+export function installCrashLogging(opts = {}) {
+    const handlers = buildCrashLoggingHandlers(opts);
+    const registrations = [];
+    const add = (event, fn) => {
+        process.on(event, fn);
+        registrations.push({ event, fn });
+    };
+    add("uncaughtException", (err) => handlers.uncaughtException(err));
+    add("unhandledRejection", (reason) => handlers.unhandledRejection(reason));
+    add("beforeExit", (code) => handlers.beforeExit(code));
+    const signals = ["SIGINT", "SIGTERM", "SIGHUP"];
+    if (process.platform === "win32")
+        signals.push("SIGBREAK");
+    for (const sig of signals) {
+        add(sig, () => handlers.signalLogger(sig));
+    }
+    return {
+        handlers,
+        cleanup: () => {
+            for (const { event, fn } of registrations) {
+                process.off(event, fn);
+            }
+            registrations.length = 0;
+        },
+    };
+}
+// ---------------------------------------------------------------------------
+// 文件日志：同时输出到控制台和日志文件
+// ---------------------------------------------------------------------------
+export function setupFileLogging(logDir, prefix) {
+    mkdirSync(logDir, { recursive: true });
+    const ts = new Date().toISOString().replace(/[:.]/g, "-").slice(0, 19);
+    const logPath = join(logDir, `${prefix}-${ts}.log`);
+    writeFileSync(logPath, "", { flag: "a", encoding: "utf8" });
+    const origConsoleLog = console.log.bind(console);
+    const origConsoleError = console.error.bind(console);
+    const origConsoleWarn = console.warn.bind(console);
+    const formatArg = (arg) => {
+        if (typeof arg === "string")
+            return arg;
+        if (arg instanceof Error)
+            return arg.stack ?? arg.message;
+        return inspect(arg, { depth: 6, breakLength: Infinity, maxArrayLength: 200 });
+    };
+    const writeLine = (level, args) => {
+        try {
+            const line = args.map(formatArg).join(" ");
+            appendFileSync(logPath, `[${new Date().toISOString()}] [${level}] ${line}\n`, "utf8");
+        }
+        catch (err) {
+            try {
+                appendStartupTrace("fileLog write failed", { level, error: err instanceof Error ? err.message : String(err) });
+            }
+            catch {
+                // 日志系统自身不能影响主流程
+            }
+        }
+    };
+    console.log = (...args) => {
+        writeLine("LOG", args);
+        try {
+            origConsoleLog(...args);
+        }
+        catch {
+            // 控制台输出失败也不能拖垮服务
+        }
+    };
+    console.error = (...args) => {
+        writeLine("ERR", args);
+        try {
+            origConsoleError(...args);
+        }
+        catch {
+            // 控制台输出失败也不能拖垮服务
+        }
+    };
+    // warn 同样落盘并兜底：飞书 SDK 等第三方库内部用 console.warn 打日志，
+    // 若不走这里（直接写 stderr），restart 后管道断开时会 EPIPE 崩溃。
+    console.warn = (...args) => {
+        writeLine("WARN", args);
+        try {
+            origConsoleWarn(...args);
+        }
+        catch {
+            // 控制台输出失败也不能拖垮服务
+        }
+    };
+    const flush = () => {
+        try {
+            appendFileSync(logPath, "", "utf8");
+        }
+        catch (err) {
+            appendStartupTrace("fileLog flush failed", { error: err instanceof Error ? err.message : String(err) });
+        }
+    };
+    origConsoleLog(`Log file: ${logPath}`);
+    return { logPath, flush };
+}
+// ---------------------------------------------------------------------------
+// 本地 WebSocket 中继服务器（同一端口、多客户端广播）
+// ---------------------------------------------------------------------------
+/**
+ * 把 WS 中继挂到一个**已存在**的 httpServer 上（不负责 listen / close）。
+ *
+ * 之所以拆出来：setup → service「在线切换」复用同一个 httpServer，
+ * 避免 close + recreate 在 Windows 下的端口释放竞态（EADDRINUSE 抖动）。
+ *
+ * 调用方负责 httpServer 的生命周期管理（listen / 错误处理 / close）。
+ */
+export function attachRelayWebSocket(httpServer) {
+    const clients = new Set();
+    const wsServer = new WebSocketServer({ server: httpServer });
+    wsServer.on("connection", (ws) => {
+        console.log(`[RELAY] Client connected (total: ${clients.size + 1})`);
+        clients.add(ws);
+        ws.on("close", () => {
+            clients.delete(ws);
+            console.log(`[RELAY] Client disconnected (total: ${clients.size})`);
+        });
+        ws.on("error", () => { clients.delete(ws); });
+    });
+    const broadcast = (data) => {
+        const json = typeof data === "string" ? data : JSON.stringify(data);
+        for (const ws of clients) {
+            if (ws.readyState === WebSocket.OPEN)
+                ws.send(json);
+        }
+    };
+    // close 用于 setup-activate 失败回滚：解绑 WSServer 在 httpServer 上注册的
+    // upgrade 监听并断开所有客户端，避免下次重试 attach 时重复挂载导致泄漏。
+    // httpServer 本身不在这里关——它在 setup 模式下还要继续给前端服务。
+    const close = () => {
+        for (const ws of clients) {
+            try {
+                ws.terminate();
+            }
+            catch { /* ok */ }
+        }
+        clients.clear();
+        try {
+            wsServer.close();
+        }
+        catch { /* ok */ }
+    };
+    return { broadcast, close };
+}
+export function createRelayServer(port) {
+    const httpServer = createServer();
+    httpServer.on("error", (err) => {
+        console.error(`[启动] 本地中继 WebSocket 监听失败：端口 ${port}（${err.code ?? "?"} — ${err.message}）`);
+        console.error("  处理建议: 关闭占用该端口的其它程序，或在 config.json 的 port 字段里改成其它未占用端口（如 18081）。");
+        printServiceDidNotStart(`本地中继端口 ${port} 无法监听（${err.code ?? "?"} — ${err.message}）`);
+        process.exit(1);
+    });
+    const { broadcast } = attachRelayWebSocket(httpServer);
+    httpServer.listen(port, "127.0.0.1", () => {
+        console.log(`[RELAY] Local relay listening on ws://127.0.0.1:${port}`);
+    });
+    return { server: httpServer, broadcast };
+}

package/dist/src/sim-agent.js

@@ -0,0 +1,105 @@
+/**
+ * sim-agent.ts — SimAgent: 模拟飞书用户的编程接口
+ *
+ * SimAgent 代表一个模拟飞书用户，提供纯代码 API：
+ * - sendMessage(): 发送消息给 bot
+ * - on("message"): 订阅 bot 和其他人的回复
+ * - on("invited_to_group"): 当被拉入群时收到通知
+ * - waitForReply(): Promise 模式等待 bot 回复
+ * - getMessages(): 查看会话历史消息
+ *
+ * 不依赖 UI，进程内直接调用，适合用于自动化测试和 Agent 编程。
+ */
+import { simStore, dispatchMessage } from "./sim-store.js";
+// ---------------------------------------------------------------------------
+// 实现
+// ---------------------------------------------------------------------------
+export function createSimAgent(userId) {
+    const account = simStore.getAccount(userId);
+    if (!account)
+        throw new Error(`Account "${userId}" not found. Register it in simStore first.`);
+    if (account.kind !== "user")
+        throw new Error(`Account "${userId}" is not a user account.`);
+    // 确保用户有至少一个会话（bot 私聊自动创建）
+    simStore.createP2pChat(userId);
+    function onEvent(event, handler) {
+        if (event === "message") {
+            const messageHandler = handler;
+            const filteredHandler = (payload) => {
+                // 只推送给该用户所在群的消息
+                const chat = simStore.getChat(payload.chatId);
+                if (chat && chat.memberIds.includes(userId)) {
+                    messageHandler(payload.chatId, payload.message);
+                }
+            };
+            // 保存映射以便 off 能移除
+            handler.__filtered = filteredHandler;
+            simStore.on("message", filteredHandler);
+        }
+        else {
+            const invitedHandler = handler;
+            const filteredHandler = (payload) => {
+                if (payload.userId === userId) {
+                    invitedHandler(payload.chatId, payload.userId);
+                }
+            };
+            handler.__filtered = filteredHandler;
+            simStore.on("member_added", filteredHandler);
+        }
+    }
+    function offEvent(event, handler) {
+        const filtered = handler.__filtered;
+        if (event === "message" && filtered) {
+            simStore.off("message", filtered);
+        }
+        else if (event === "invited_to_group" && filtered) {
+            simStore.off("member_added", filtered);
+        }
+    }
+    const agent = {
+        userId,
+        account,
+        async sendMessage(chatId, text) {
+            const chat = simStore.getChat(chatId);
+            if (!chat)
+                throw new Error(`Chat "${chatId}" not found`);
+            if (!chat.memberIds.includes(userId)) {
+                throw new Error(`User "${userId}" is not a member of chat "${chatId}"`);
+            }
+            await dispatchMessage(text, chatId, userId, chat.type === "p2p" ? "p2p" : "group");
+        },
+        createP2pWithBot() {
+            const chat = simStore.createP2pChat(userId);
+            return chat.id;
+        },
+        getMessages(chatId) {
+            return simStore.getMessages(chatId, userId);
+        },
+        listChats() {
+            return simStore.getChatsForUser(userId).map((c) => ({
+                id: c.id,
+                name: c.name,
+                type: c.type,
+            }));
+        },
+        on: onEvent,
+        off: offEvent,
+        waitForReply(chatId, timeoutMs = 30000) {
+            return new Promise((resolve) => {
+                const timer = setTimeout(() => {
+                    agent.off("message", onMessage);
+                    resolve(null);
+                }, timeoutMs);
+                const onMessage = (cid, msg) => {
+                    if (cid === chatId && msg.senderId === "bot") {
+                        clearTimeout(timer);
+                        agent.off("message", onMessage);
+                        resolve(msg);
+                    }
+                };
+                agent.on("message", onMessage);
+            });
+        },
+    };
+    return agent;
+}