chatccc 0.2.252 → 0.2.254

package/dist/src/agent-stop-stuck.js

@@ -0,0 +1,110 @@
+import { readUtf8JsonBody } from "./agent-rpc-body.js";
+import { activePrompts, getChatsForSession } from "./session-chat-binding.js";
+import { getPlatformForChat } from "./session.js";
+import { readStreamState, writeStreamState } from "./stream-state.js";
+import { ts } from "./config.js";
+export const AGENT_STOP_STUCK_PATH = "/api/agent/stop-stuck-loop";
+const MAX_REQUEST_BYTES = 8 * 1024;
+function jsonReply(res, status, data) {
+    res.writeHead(status, { "Content-Type": "application/json; charset=utf-8" });
+    res.end(JSON.stringify(data));
+}
+/**
+ * 从原始 body 字节中用正则尽力提取 session_id。
+ * 兼容 JSON 编码异常（如 GBK 中文导致 JSON.parse 失败）的场景。
+ */
+function extractSessionIdFromRaw(buf) {
+    // 匹配 "session_id":"<uuid>" 或 "session_id": "<uuid>"
+    const match = buf.toString("latin1").match(/"session_id"\s*:\s*"([^"]+)"/);
+    return match?.[1] ?? null;
+}
+export async function handleAgentStopStuckRequest(req, res) {
+    const url = new URL(req.url ?? "/", "http://127.0.0.1");
+    if (url.pathname !== AGENT_STOP_STUCK_PATH)
+        return false;
+    if (req.method !== "POST") {
+        jsonReply(res, 405, { error: "Method not allowed, use POST" });
+        return true;
+    }
+    let body;
+    let rawBody = null;
+    try {
+        body = await readUtf8JsonBody(req, MAX_REQUEST_BYTES);
+    }
+    catch (err) {
+        // JSON 解析失败时仍尝试从原始字节中提取 session_id 并强行停止
+        // 宁可输出乱码，也不能让 agent 持续循环
+        rawBody = err.rawBody ?? null;
+        if (!rawBody) {
+            jsonReply(res, 400, { error: `Invalid request body: ${err.message}` });
+            return true;
+        }
+        const fallbackId = extractSessionIdFromRaw(rawBody);
+        if (!fallbackId) {
+            jsonReply(res, 400, { error: `Invalid request body: ${err.message}` });
+            return true;
+        }
+        body = { session_id: fallbackId };
+    }
+    const sessionId = typeof body?.session_id === "string" ? body.session_id.trim() : "";
+    if (!sessionId) {
+        jsonReply(res, 400, { error: "session_id is required" });
+        return true;
+    }
+    const prompt = activePrompts.get(sessionId);
+    if (!prompt) {
+        jsonReply(res, 404, { error: "Session not found or not running" });
+        return true;
+    }
+    // 先发"卡住"提示消息给所有绑定的群聊
+    const chats = getChatsForSession(sessionId);
+    for (const chatId of chats) {
+        const platform = getPlatformForChat(chatId);
+        if (platform) {
+            await platform.sendText(chatId, "⚠️ Agent 检测到自己陷入了循环，正在结束生成…").catch(() => { });
+        }
+    }
+    // 不丢弃缓存队列中的消息，让 runAgentSession 的 finally 块正常消费，
+    // 确保 stop-stuck-loop 结束后排队的消息仍能被正常处理。
+    const finalReply = typeof body?.final_reply === "string" ? body.final_reply.trim() : "";
+    // fire-and-forget：立即把 stream-state 标为 done（而非 stopped），
+    // 让 display loop 以"正常完成"而非"已停止"来渲染卡片和最终回复。
+    // 不设 prompt.stopped = true，这样 runAgentSession 的 finally 也会写 "done"。
+    void (async () => {
+        try {
+            const current = await readStreamState(sessionId);
+            if (!current)
+                return;
+            if (current.status !== "running")
+                return;
+            await writeStreamState({
+                ...current,
+                status: "done",
+                stuckAt: Date.now(),
+                finalReply: finalReply ? current.finalReply + "\n\n" + finalReply : current.finalReply,
+                updatedAt: Date.now(),
+            });
+        }
+        catch (err) {
+            console.warn(`[${ts()}] [STUCK-LOOP] writeStreamState(done) failed for ${sessionId}: ${err.message}`);
+        }
+    })();
+    // 先关闭底层 SDK session，终止 CLI 子进程，然后再 abort 清理 adapter 层
+    prompt.closeSession?.();
+    // 强制杀死 CLI 子进程。controller.abort() 只在 for-await 收到下一条
+    // stream 消息时才被检测到——如果 agent 陷入无输出的计算循环，abort 信号
+    // 永远不会生效；SDK 的 session.close() 也不保证立即终止子进程。
+    if (prompt.processPid !== undefined) {
+        try {
+            process.kill(prompt.processPid);
+        }
+        catch {
+            // 进程可能已退出，忽略错误
+        }
+    }
+    // 不设 stopped 标记 → finally block 写 "done" → 卡片正常结束
+    prompt.controller.abort();
+    console.log(`[${ts()}] [STUCK-LOOP] Session ${sessionId} aborted as done (agent detected stuck loop, final_reply=${finalReply ? "yes" : "no"})`);
+    jsonReply(res, 200, { ok: true });
+    return true;
+}

package/dist/src/agent-team/application/board-service.js

@@ -0,0 +1,142 @@
+import { randomUUID } from "node:crypto";
+import { isAgentTool } from "../../agent-tool.js";
+import { isBoardColumnId } from "../domain/board.js";
+import { BoardStoreError } from "../repositories/board-repository.js";
+export class BoardService {
+    repository;
+    now;
+    idFactory;
+    constructor(repository, options = {}) {
+        this.repository = repository;
+        this.now = options.now ?? (() => new Date());
+        this.idFactory = options.idFactory ?? randomUUID;
+    }
+    openWorkspace(workspacePath) {
+        return this.repository.openWorkspace(workspacePath);
+    }
+    findWorkspace(workspacePath) {
+        return this.repository.findWorkspace(workspacePath);
+    }
+    getBoard(boardId) {
+        return this.repository.getBoard(boardId);
+    }
+    listWorkspaces() {
+        return this.repository.listWorkspaces();
+    }
+    relinkWorkspace(boardId, workspacePath, expectedRevision) {
+        assertRevision(expectedRevision);
+        return this.repository.relinkWorkspace(boardId, workspacePath, expectedRevision);
+    }
+    setPrimaryAgent(boardId, agentId, expectedRevision) {
+        if (!isAgentTool(agentId)) {
+            throw new BoardStoreError("invalid_request", `Unsupported primary Agent: ${String(agentId)}`, 400);
+        }
+        return this.mutate(boardId, expectedRevision, (board) => ({ ...board, primaryAgentId: agentId }));
+    }
+    createTask(boardId, input) {
+        const title = cleanTitle(input.title);
+        const description = cleanDescription(input.description ?? "");
+        const columnId = cleanColumn(input.columnId);
+        return this.mutate(boardId, input.expectedRevision, (board, now) => {
+            const siblings = activeTasks(board, columnId);
+            const task = {
+                id: this.idFactory(),
+                title,
+                description,
+                columnId,
+                order: (siblings.at(-1)?.order ?? 0) + 1000,
+                createdAt: now,
+                updatedAt: now,
+                deletedAt: null,
+            };
+            return { ...board, tasks: [...board.tasks, task] };
+        });
+    }
+    updateTask(boardId, taskId, input) {
+        const title = cleanTitle(input.title);
+        const description = cleanDescription(input.description ?? "");
+        return this.mutate(boardId, input.expectedRevision, (board, now) => ({
+            ...board,
+            tasks: board.tasks.map((task) => task.id === taskId && !task.deletedAt
+                ? { ...task, title, description, updatedAt: now }
+                : task),
+        }), taskId);
+    }
+    moveTask(boardId, taskId, input) {
+        const targetColumn = cleanColumn(input.columnId);
+        if (!Number.isInteger(input.index) || input.index < 0) {
+            throw new BoardStoreError("invalid_request", "Task index must be a non-negative integer", 400);
+        }
+        return this.mutate(boardId, input.expectedRevision, (board, now) => {
+            const moving = board.tasks.find((task) => task.id === taskId && !task.deletedAt);
+            const sourceColumn = moving.columnId;
+            const targetTasks = activeTasks(board, targetColumn).filter((task) => task.id !== taskId);
+            targetTasks.splice(Math.min(input.index, targetTasks.length), 0, { ...moving, columnId: targetColumn, updatedAt: now });
+            const targetTaskIds = new Set(targetTasks.map((task) => task.id));
+            let tasks = board.tasks.filter((task) => task.id !== taskId && !targetTaskIds.has(task.id));
+            tasks.push(...targetTasks.map((task, index) => ({ ...task, columnId: targetColumn, order: (index + 1) * 1000 })));
+            if (sourceColumn !== targetColumn) {
+                const sourceTasks = activeTasks({ ...board, tasks }, sourceColumn);
+                const sourceIds = new Set(sourceTasks.map((task) => task.id));
+                tasks = tasks.map((task) => sourceIds.has(task.id)
+                    ? { ...task, order: (sourceTasks.findIndex((source) => source.id === task.id) + 1) * 1000 }
+                    : task);
+            }
+            return { ...board, tasks };
+        }, taskId);
+    }
+    deleteTask(boardId, taskId, input) {
+        return this.mutate(boardId, input.expectedRevision, (board, now) => ({
+            ...board,
+            tasks: board.tasks.map((task) => task.id === taskId && !task.deletedAt
+                ? { ...task, deletedAt: now, updatedAt: now }
+                : task),
+        }), taskId);
+    }
+    async mutate(boardId, expectedRevision, transform, requiredTaskId) {
+        assertRevision(expectedRevision);
+        const board = await this.repository.getBoard(boardId);
+        if (board.revision !== expectedRevision) {
+            throw new BoardStoreError("revision_conflict", `Board changed in another page (expected revision ${expectedRevision}, current ${board.revision})`, 409);
+        }
+        if (requiredTaskId && !board.tasks.some((task) => task.id === requiredTaskId && !task.deletedAt)) {
+            throw new BoardStoreError("not_found", `Task not found: ${requiredTaskId}`, 404);
+        }
+        const now = this.now().toISOString();
+        const next = transform(board, now);
+        const updated = { ...next, revision: board.revision + 1, updatedAt: now };
+        await this.repository.saveBoard(updated, board.revision);
+        return updated;
+    }
+}
+function assertRevision(value) {
+    if (!Number.isInteger(value) || value < 0) {
+        throw new BoardStoreError("invalid_request", "expectedRevision must be a non-negative integer", 400);
+    }
+}
+function cleanTitle(value) {
+    if (typeof value !== "string" || !value.trim()) {
+        throw new BoardStoreError("invalid_request", "Task title must be a non-empty string", 400);
+    }
+    const title = value.trim();
+    if (title.length > 200)
+        throw new BoardStoreError("invalid_request", "Task title cannot exceed 200 characters", 400);
+    return title;
+}
+function cleanDescription(value) {
+    if (typeof value !== "string")
+        throw new BoardStoreError("invalid_request", "Task description must be a string", 400);
+    if (value.length > 20_000)
+        throw new BoardStoreError("invalid_request", "Task description cannot exceed 20000 characters", 400);
+    return value;
+}
+function cleanColumn(value) {
+    if (!isBoardColumnId(value))
+        throw new BoardStoreError("invalid_request", `Unknown board column: ${String(value)}`, 400);
+    return value;
+}
+function activeTasks(board, columnId) {
+    return board.tasks
+        .filter((task) => !task.deletedAt && task.columnId === columnId)
+        .sort((a, b) => a.order - b.order || a.createdAt.localeCompare(b.createdAt));
+}

package/dist/src/agent-team/application/main-agent-service.js

@@ -0,0 +1,151 @@
+import { isAgentTool } from "../../agent-tool.js";
+import { sessionChatName } from "../../session-name.js";
+import { BoardStoreError } from "../repositories/board-repository.js";
+export class MainAgentService {
+    options;
+    now;
+    projectOperations = new Map();
+    constructor(options) {
+        this.options = options;
+        this.now = options.now ?? (() => new Date());
+    }
+    getContact() {
+        return this.options.contactStore.get();
+    }
+    getBinding(projectId) {
+        return this.options.bindingRepository.get(projectId);
+    }
+    setPrimaryAgent(projectId, agentId, expectedRevision) {
+        if (!isAgentTool(agentId)) {
+            throw new BoardStoreError("invalid_request", `Unsupported primary Agent: ${String(agentId)}`, 400);
+        }
+        return this.exclusive(projectId, async () => {
+            const board = await this.options.boardService.getBoard(projectId);
+            if (board.revision !== expectedRevision) {
+                throw new BoardStoreError("revision_conflict", `Board changed in another page (expected revision ${expectedRevision}, current ${board.revision})`, 409);
+            }
+            return this.provision(board, agentId, false);
+        });
+    }
+    relinkWorkspace(projectId, workspacePath, expectedRevision) {
+        return this.exclusive(projectId, async () => {
+            const existing = await this.options.bindingRepository.get(projectId);
+            const currentSessionId = existing ? (await this.resolveCurrentSession(existing)).sessionId : null;
+            if (currentSessionId && this.options.runtime.isSessionRunning(currentSessionId)) {
+                throw new BoardStoreError("main_agent_running", "主 Agent 正在执行任务，请先停止后再重新关联目录", 409);
+            }
+            const board = await this.options.boardService.relinkWorkspace(projectId, workspacePath, expectedRevision);
+            if (!existing || !board.primaryAgentId)
+                return { board, binding: null };
+            return this.provision(board, board.primaryAgentId, true);
+        });
+    }
+    async provision(board, agentId, forceNewSession) {
+        const existing = await this.options.bindingRepository.get(board.boardId);
+        const currentSession = existing ? await this.resolveCurrentSession(existing) : null;
+        const currentSessionId = currentSession?.sessionId ?? null;
+        if (currentSessionId && this.options.runtime.isSessionRunning(currentSessionId)) {
+            throw new BoardStoreError("main_agent_running", "主 Agent 正在执行任务，请先停止后再切换", 409);
+        }
+        if (!forceNewSession &&
+            existing?.status === "ready" &&
+            existing.agentId === agentId &&
+            currentSession?.agentId === agentId) {
+            const savedBoard = board.primaryAgentId === agentId
+                ? board
+                : await this.options.boardService.setPrimaryAgent(board.boardId, agentId, board.revision);
+            return { board: savedBoard, binding: existing };
+        }
+        const contact = existing?.ownerOpenId
+            ? { openId: existing.ownerOpenId }
+            : await this.options.contactStore.get();
+        if (!contact) {
+            throw new BoardStoreError("feishu_dm_required", "请先给飞书机器人私聊发送任意消息，再回到网页重试", 409);
+        }
+        const chatName = sessionChatName("主Agent", board.workspacePath);
+        let binding = {
+            schemaVersion: 1,
+            projectId: board.boardId,
+            platform: "feishu",
+            ...(existing?.chatId ? { chatId: existing.chatId } : {}),
+            ...(currentSessionId ? { sessionId: currentSessionId } : {}),
+            agentId,
+            namingPolicy: "project-fixed",
+            status: "provisioning",
+            ownerOpenId: contact.openId,
+            updatedAt: this.now().toISOString(),
+        };
+        await this.options.bindingRepository.save(binding);
+        try {
+            const created = await this.options.runtime.createSession(agentId, board.workspacePath);
+            let chatId = existing?.chatId;
+            if (!chatId) {
+                chatId = await this.options.platform.createGroup(chatName, [contact.openId]);
+            }
+            binding = {
+                ...binding,
+                chatId,
+                sessionId: created.sessionId,
+                updatedAt: this.now().toISOString(),
+            };
+            // Persist irreversible identifiers before the remaining steps so a retry reuses the group.
+            await this.options.bindingRepository.save(binding);
+            await this.options.runtime.bindSession({
+                chatId,
+                oldSessionId: currentSessionId,
+                newSessionId: created.sessionId,
+                agentId,
+                cwd: created.cwd,
+                chatName,
+                namingPolicy: "project-fixed",
+            });
+            binding = { ...binding, status: "ready", updatedAt: this.now().toISOString() };
+            await this.options.bindingRepository.save(binding);
+            const savedBoard = board.primaryAgentId === agentId
+                ? board
+                : await this.options.boardService.setPrimaryAgent(board.boardId, agentId, board.revision);
+            await this.options.platform.sendCard(chatId, "主 Agent 已就绪", `项目：**${chatName.slice("主Agent-".length)}**\n\n工作目录：\`${created.cwd}\`\n\n可以直接在本群与主 Agent 对话。`, "green").catch(() => false);
+            return { board: savedBoard, binding };
+        }
+        catch (err) {
+            const failed = {
+                ...binding,
+                status: "error",
+                lastError: err.message,
+                updatedAt: this.now().toISOString(),
+            };
+            await this.options.bindingRepository.save(failed).catch(() => { });
+            throw err;
+        }
+    }
+    async resolveCurrentSession(binding) {
+        if (!binding.chatId)
+            return { sessionId: binding.sessionId ?? null, agentId: binding.agentId };
+        try {
+            const info = await this.options.platform.getChatInfo(binding.chatId);
+            const session = this.options.platform.extractSessionInfo(info.description);
+            return {
+                sessionId: session?.sessionId ?? binding.sessionId ?? null,
+                agentId: isAgentTool(session?.tool) ? session.tool : binding.agentId,
+            };
+        }
+        catch {
+            return { sessionId: binding.sessionId ?? null, agentId: binding.agentId };
+        }
+    }
+    async exclusive(projectId, operation) {
+        const previous = this.projectOperations.get(projectId) ?? Promise.resolve();
+        let release;
+        const current = new Promise((resolve) => { release = resolve; });
+        this.projectOperations.set(projectId, current);
+        await previous;
+        try {
+            return await operation();
+        }
+        finally {
+            release();
+            if (this.projectOperations.get(projectId) === current)
+                this.projectOperations.delete(projectId);
+        }
+    }
+}

package/dist/src/agent-team/domain/board.js

@@ -0,0 +1,69 @@
+import { isAgentTool } from "../../agent-tool.js";
+export const BOARD_SCHEMA_VERSION = 1;
+export const BOARD_COLUMNS = [
+    { id: "brainstorm", title: "头脑风暴", order: 0 },
+    { id: "todo", title: "Todo", order: 1 },
+    { id: "doing", title: "Doing", order: 2 },
+    { id: "done", title: "Done", order: 3 },
+    { id: "on_hold", title: "搁置", order: 4 },
+];
+export const BOARD_COLUMN_IDS = new Set(BOARD_COLUMNS.map((column) => column.id));
+export function isBoardColumnId(value) {
+    return typeof value === "string" && BOARD_COLUMN_IDS.has(value);
+}
+export function createEmptyBoard(input) {
+    return {
+        schemaVersion: BOARD_SCHEMA_VERSION,
+        boardId: input.boardId,
+        workspacePath: input.workspacePath,
+        revision: 0,
+        columns: BOARD_COLUMNS.map((column) => ({ ...column })),
+        tasks: [],
+        createdAt: input.now,
+        updatedAt: input.now,
+    };
+}
+export function parseBoard(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new Error("Board JSON must be an object");
+    const board = value;
+    if (board.schemaVersion !== BOARD_SCHEMA_VERSION)
+        throw new Error(`Unsupported board schema version: ${String(board.schemaVersion)}`);
+    if (typeof board.boardId !== "string" || !board.boardId)
+        throw new Error("Board is missing boardId");
+    if (typeof board.workspacePath !== "string" || !board.workspacePath)
+        throw new Error("Board is missing workspacePath");
+    if (board.primaryAgentId !== undefined && !isAgentTool(board.primaryAgentId)) {
+        throw new Error(`Unsupported primary Agent: ${String(board.primaryAgentId)}`);
+    }
+    if (!Number.isInteger(board.revision) || board.revision < 0)
+        throw new Error("Board revision is invalid");
+    if (!Array.isArray(board.tasks))
+        throw new Error("Board tasks must be an array");
+    for (const task of board.tasks) {
+        if (!task || typeof task !== "object")
+            throw new Error("Board task is invalid");
+        const candidate = task;
+        if (typeof candidate.id !== "string" || !candidate.id)
+            throw new Error("Board task is missing id");
+        if (typeof candidate.title !== "string")
+            throw new Error("Board task title is invalid");
+        if (typeof candidate.description !== "string")
+            throw new Error("Board task description is invalid");
+        if (!isBoardColumnId(candidate.columnId))
+            throw new Error(`Unknown board column: ${String(candidate.columnId)}`);
+        if (!Number.isFinite(candidate.order))
+            throw new Error("Board task order is invalid");
+        if (typeof candidate.createdAt !== "string" || typeof candidate.updatedAt !== "string") {
+            throw new Error("Board task timestamps are invalid");
+        }
+        if (candidate.deletedAt !== null && typeof candidate.deletedAt !== "string") {
+            throw new Error("Board task deletedAt is invalid");
+        }
+    }
+    return {
+        ...board,
+        columns: BOARD_COLUMNS.map((column) => ({ ...column })),
+        tasks: board.tasks,
+    };
+}