chatccc 0.2.252 → 0.2.254

package/dist/src/package-root.js

@@ -0,0 +1,26 @@
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join, parse } from "node:path";
+import { fileURLToPath } from "node:url";
+/** Locate the installed ChatCCC package root from either src/ or dist/src/. */
+export function findChatCccPackageRoot(startDir = dirname(fileURLToPath(import.meta.url))) {
+    let current = startDir;
+    const filesystemRoot = parse(current).root;
+    while (true) {
+        const packagePath = join(current, "package.json");
+        if (existsSync(packagePath)) {
+            try {
+                const pkg = JSON.parse(readFileSync(packagePath, "utf8"));
+                if (pkg.name === "chatccc")
+                    return current;
+            }
+            catch {
+                // Keep walking: a malformed unrelated package.json is not our root.
+            }
+        }
+        if (current === filesystemRoot)
+            break;
+        current = dirname(current);
+    }
+    throw new Error(`Unable to locate ChatCCC package root from ${startDir}`);
+}
+export const CHATCCC_PACKAGE_ROOT = findChatCccPackageRoot();

package/dist/src/platform-adapter.js

@@ -0,0 +1,7 @@
+/**
+ * platform-adapter.ts — IM 平台适配器接口
+ *
+ * 独立于 orchestrator.ts，避免 orchestrator ↔ session 循环依赖。
+ * 每个方法内部自行管理认证，消费者不感知 token 等认证细节。
+ */
+export {};

package/dist/src/platform-startup.js

@@ -0,0 +1,6 @@
+export function buildPlatformStartupPlan(input) {
+    return {
+        startFeishu: input.feishuEnabled,
+        startIlink: input.ilinkEnabled,
+    };
+}

package/dist/src/privacy.js

@@ -0,0 +1,100 @@
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { USER_DATA_DIR } from "./config.js";
+let config = null;
+let loadedStamp;
+function privacyFilePath() {
+    return join(USER_DATA_DIR, "privacy.json");
+}
+function privacyFileStamp() {
+    const filePath = privacyFilePath();
+    if (!existsSync(filePath))
+        return null;
+    try {
+        const s = statSync(filePath);
+        return `${s.mtimeMs}:${s.size}`;
+    }
+    catch {
+        return null;
+    }
+}
+function sanitizeRules(raw) {
+    const result = {};
+    for (const [from, to] of Object.entries(raw)) {
+        if (!from) {
+            console.error("[PRIVACY] privacy.json rule key cannot be empty, skipped");
+            continue;
+        }
+        if (typeof to !== "string") {
+            console.error(`[PRIVACY] privacy.json value must be a string, skipped "${from}"`);
+            continue;
+        }
+        result[from] = to;
+    }
+    return result;
+}
+function normalizeConfig(parsed) {
+    const hasNewSchema = Object.prototype.hasOwnProperty.call(parsed, "enabled") ||
+        Object.prototype.hasOwnProperty.call(parsed, "rules");
+    if (!hasNewSchema) {
+        return { enabled: true, rules: sanitizeRules(parsed) };
+    }
+    const enabledRaw = parsed.enabled;
+    const enabled = enabledRaw === undefined ? true : enabledRaw !== false;
+    if (enabledRaw !== undefined && typeof enabledRaw !== "boolean") {
+        console.error("[PRIVACY] privacy.json enabled must be a boolean, using true");
+    }
+    const rulesRaw = parsed.rules;
+    if (rulesRaw === undefined)
+        return { enabled, rules: {} };
+    if (typeof rulesRaw !== "object" || rulesRaw === null || Array.isArray(rulesRaw)) {
+        console.error("[PRIVACY] privacy.json rules must be an object");
+        return { enabled, rules: {} };
+    }
+    return { enabled, rules: sanitizeRules(rulesRaw) };
+}
+function loadConfig() {
+    const filePath = privacyFilePath();
+    if (!existsSync(filePath)) {
+        return { enabled: true, rules: {} };
+    }
+    try {
+        const raw = readFileSync(filePath, "utf-8").replace(/^\uFEFF/, "");
+        const parsed = JSON.parse(raw);
+        if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+            console.error("[PRIVACY] privacy.json must be an object");
+            return { enabled: true, rules: {} };
+        }
+        return normalizeConfig(parsed);
+    }
+    catch (err) {
+        console.error(`[PRIVACY] failed to read privacy.json: ${err.message}`);
+        return { enabled: true, rules: {} };
+    }
+}
+export function getPrivacyConfig() {
+    const stamp = privacyFileStamp();
+    if (!config || stamp !== loadedStamp) {
+        config = loadConfig();
+        loadedStamp = stamp;
+    }
+    return config;
+}
+export function getPrivacyRules() {
+    return getPrivacyConfig().rules;
+}
+export function reloadPrivacyRules() {
+    config = null;
+    loadedStamp = undefined;
+}
+export function applyPrivacy(text) {
+    const { enabled, rules } = getPrivacyConfig();
+    if (!enabled || Object.keys(rules).length === 0 || !text)
+        return text;
+    let result = text;
+    for (const [from, to] of Object.entries(rules)) {
+        // Use split+join instead of regex replacement so rule keys stay literal.
+        result = result.split(from).join(to);
+    }
+    return result;
+}

package/dist/src/progress/reducer.js

@@ -0,0 +1,102 @@
+/**
+ * progress/reducer.ts — ChatEvent 事件流 → ProgressView 的增量合并
+ *
+ * 这是飞书与终端共享的唯一一份"事件 → 过程视图"公共逻辑：
+ * 终端 REPL 直接消费 ChatSession.chat() 的事件流，逐条 reduce；
+ * 飞书侧 display loop 若未来接入事件流，同样使用本 reducer，保证两端
+ * 看到的过程状态（正文累积、工具调用、终态判定）完全一致。
+ */
+import { withProgressView, } from "./view.js";
+/** 工具调用 input 单行摘要（终端折叠行展示用） */
+export function summarizeToolInput(input, maxChars = 120) {
+    let raw;
+    if (typeof input === "string") {
+        raw = input;
+    }
+    else {
+        try {
+            raw = JSON.stringify(input);
+        }
+        catch {
+            raw = String(input);
+        }
+    }
+    const oneLine = raw.replace(/\s+/g, " ").trim();
+    return oneLine.length > maxChars ? oneLine.slice(0, maxChars) + "…" : oneLine;
+}
+/** 工具结果单行摘要（成功/失败各取首行） */
+export function summarizeToolResult(content, maxChars = 120) {
+    let raw;
+    if (typeof content === "string") {
+        raw = content;
+    }
+    else if (content instanceof Error) {
+        raw = content.message;
+    }
+    else {
+        try {
+            raw = JSON.stringify(content);
+        }
+        catch {
+            raw = String(content);
+        }
+    }
+    const firstLine = raw.split("\n")[0] ?? "";
+    return firstLine.length > maxChars ? firstLine.slice(0, maxChars) + "…" : firstLine;
+}
+/**
+ * 把一条 ChatEvent 合并进 ProgressView，返回新视图（不可变更新）。
+ * 未识别的/不影响展示的事件（如 compact）返回原视图。
+ */
+export function reduceProgress(prev, event) {
+    switch (event.type) {
+        case "status":
+            return withProgressView(prev, {
+                headerTitle: event.phase === "compacting" ? "压缩上下文中..." : "生成回复中...",
+            });
+        case "text":
+            // accumulated 是全文累积，直接全量替换，天然幂等
+            return withProgressView(prev, { text: event.accumulated });
+        case "tool_use": {
+            const tool = {
+                id: event.id ?? `tool-${prev.tools.length + 1}`,
+                name: event.name,
+                status: "running",
+                detail: summarizeToolInput(event.input),
+            };
+            return withProgressView(prev, { tools: [...prev.tools, tool] });
+        }
+        case "tool_result": {
+            const nextStatus = event.is_error ? "error" : "ok";
+            const summary = summarizeToolResult(event.content);
+            let matched = false;
+            const tools = prev.tools.map((t) => {
+                if (matched || t.id !== event.tool_use_id)
+                    return t;
+                matched = true;
+                return { ...t, status: nextStatus, summary };
+            });
+            if (!matched) {
+                // id 缺失或失配：兜底更新最后一个 running 工具，避免状态悬挂
+                const lastRunning = [...prev.tools].reverse().findIndex((t) => t.status === "running");
+                if (lastRunning >= 0) {
+                    const idx = prev.tools.length - 1 - lastRunning;
+                    const updated = prev.tools.map((t, i) => i === idx ? { ...t, status: nextStatus, summary } : t);
+                    return withProgressView(prev, { tools: updated });
+                }
+            }
+            return withProgressView(prev, { tools });
+        }
+        case "done":
+            return withProgressView(prev, {
+                status: "done",
+                showStop: false,
+                text: event.text,
+            });
+        case "error":
+            return withProgressView(prev, { status: "error", showStop: false });
+        case "compact":
+            // 旧上下文压缩不影响当前过程展示
+            return prev;
+    }
+}

package/dist/src/progress/terminal-renderer.js

@@ -0,0 +1,264 @@
+/**
+ * progress/terminal-renderer.ts — 终端"过程区块"渲染器
+ *
+ * 把 ProgressView 渲染为终端里的一块固定区域（对应飞书过程卡片）：
+ *   - 状态行：生成中 / 完成 / 已停止 / 异常结束
+ *   - 工具行：每个工具调用一行（emoji + 名称 + ✓/✗ + 摘要），不再滚屏刷 JSON
+ *   - 正文行：模型流式输出，原地更新不滚动
+ *
+ * 实现要点：
+ *   - 隐藏光标（\x1b[?25l）→ 每帧整块重绘（\x1b[{n}A 上移 + \x1b[2K 清行 + \x1b[J 清下方）
+ *   - 帧节流合并重绘，避免高频文本增量导致闪烁
+ *   - 每行按显示宽度截断（CJK/emoji 算 2 列），保证永不折行：一旦折行，
+ *     实际占用的屏幕行数会超过 blockLines 计数，下次重绘上移行数不足，
+ *     会清掉区块上方的历史内容（用户输入的问题被"吃掉"）。
+ *   - end() 时把终态区块定型留在屏幕上（与飞书完成卡片留在消息流语义一致），恢复光标
+ */
+import { getToolEmoji, truncateContent } from "../cards.js";
+import { progressView } from "./view.js";
+const RESET = "\x1b[0m";
+const DIM = "\x1b[2m";
+const BOLD = "\x1b[1m";
+const GREEN = "\x1b[32m";
+const YELLOW = "\x1b[33m";
+const RED = "\x1b[31m";
+const HIDE_CURSOR = "\x1b[?25l";
+const SHOW_CURSOR = "\x1b[?25h";
+/** 生成中标题后的心跳点号动画帧（1 → 2 → 3 → 2 循环，避免跳变感） */
+const ANIM_FRAMES = ["·", "··", "···", "··"];
+const ANSI_TOKEN = /\x1b\[[0-9;]*m/;
+/** 单个字符在终端里的显示列宽：CJK/emoji 占 2 列，控制符/ZWJ/变体选择符占 0 列 */
+export function charWidth(ch) {
+    const code = ch.codePointAt(0);
+    if (code < 32 || (code >= 0x7f && code <= 0xa0))
+        return 0; // 控制字符
+    if (code === 0x200d || code === 0xfe0e || code === 0xfe0f)
+        return 0; // ZWJ / VS15 / VS16
+    if ((code >= 0x1100 && code <= 0x115f) || // 谚文 Jamo
+        (code >= 0x2e80 && code <= 0x303f) || // CJK 部首 / 标点
+        (code >= 0x3040 && code <= 0xa4cf) || // 假名 / 汉字 / 谚文 / 彝文
+        (code >= 0xac00 && code <= 0xd7a3) || // 谚文音节
+        (code >= 0xf900 && code <= 0xfaff) || // CJK 兼容汉字
+        (code >= 0xfe30 && code <= 0xfe6f) || // CJK 兼容形式
+        (code >= 0xff00 && code <= 0xff60) || // 全角形式
+        (code >= 0xffe0 && code <= 0xffe6) || // 全角符号
+        (code >= 0x2600 && code <= 0x27bf) || // 杂项符号 + Dingbats（emoji 呈现 2 列）
+        (code >= 0x1f000 && code <= 0x1faff) // emoji 补充区
+    ) {
+        return 2;
+    }
+    return 1;
+}
+/**
+ * 按终端显示宽度截断一行（CJK/emoji 计 2 列），ANSI 序列零宽且永不截断。
+ * 截断位置若处于未闭合的颜色状态，自动补 \x1b[0m，避免颜色泄漏到后续输出。
+ */
+export function clipToWidth(s, maxCols) {
+    if (maxCols <= 0)
+        return "";
+    let out = "";
+    let visible = 0;
+    let colorOpen = false;
+    let i = 0;
+    while (i < s.length) {
+        if (s.charCodeAt(i) === 0x1b) {
+            const m = ANSI_TOKEN.exec(s.slice(i));
+            if (m && m.index === 0) {
+                out += m[0];
+                colorOpen = m[0] !== "\x1b[0m";
+                i += m[0].length;
+                continue;
+            }
+        }
+        const cp = s.codePointAt(i);
+        const ch = String.fromCodePoint(cp);
+        const w = charWidth(ch);
+        if (visible + w > maxCols)
+            break;
+        out += ch;
+        visible += w;
+        i += ch.length;
+    }
+    if (colorOpen)
+        out += "\x1b[0m";
+    return out;
+}
+function buildStatusLine(view) {
+    switch (view.status) {
+        case "done":
+            return `${BOLD}${GREEN}✅ 完成${RESET}`;
+        case "stopped":
+            return `${YELLOW}⏹ 已停止${RESET}`;
+        case "error":
+            return `${RED}❌ 异常结束${RESET}`;
+        case "generating": {
+            const hint = view.showStop ? `${DIM}  ·  Ctrl+C 停止${RESET}` : "";
+            return `⏳ ${view.headerTitle}${hint}`;
+        }
+    }
+}
+function buildToolLine(tool) {
+    const emoji = getToolEmoji(tool.name);
+    const mark = tool.status === "running"
+        ? "…"
+        : tool.status === "ok"
+            ? `${GREEN}✓${RESET}`
+            : `${RED}✗${RESET}`;
+    const info = tool.status === "running" ? (tool.detail ?? "") : (tool.summary ?? "");
+    // 摘要/详情用正常色：最终区块里不出现浅色文字（可读性优先）
+    return `  ${emoji} ${tool.name} ${mark} ${info}`;
+}
+/**
+ * 把 ProgressView 展开为区块的完整行列表（不含 ANSI 定位序列，只含内容与颜色）。
+ * 单独导出便于单元测试；每行按终端宽度截断，避免长行折行导致行数计数失准。
+ */
+export function buildBlockLines(view, width, maxBodyLines = 30, maxBodyChars = 12000) {
+    const clip = (s) => clipToWidth(s, width);
+    const lines = [];
+    lines.push(clip(buildStatusLine(view)));
+    for (const tool of view.tools) {
+        lines.push(clip(buildToolLine(tool)));
+    }
+    const body = truncateContent(view.text, maxBodyLines, maxBodyChars);
+    if (body.trim()) {
+        for (const line of body.split("\n")) {
+            lines.push(clip(line));
+        }
+    }
+    else {
+        lines.push(`${DIM}等待 Agent 输出...${RESET}`);
+    }
+    return lines;
+}
+export class TerminalProgressRenderer {
+    out;
+    frameMs;
+    animMs;
+    maxBodyLines;
+    maxBodyChars;
+    view;
+    blockLines = 0;
+    dirty = false;
+    timer = null;
+    ended = false;
+    animFrame = 0;
+    animTimer = null;
+    constructor(opts = {}) {
+        this.out = opts.out ?? process.stdout;
+        this.frameMs = opts.frameMs ?? 66;
+        this.animMs = opts.animMs ?? 300;
+        this.maxBodyLines = opts.maxBodyLines ?? 30;
+        this.maxBodyChars = opts.maxBodyChars ?? 12000;
+        this.view = progressView();
+    }
+    /** 开始一轮区块：隐藏光标并渲染首帧，随后启动生成中心跳动画 */
+    begin(view) {
+        this.view = view;
+        this.out.write(HIDE_CURSOR);
+        this.renderNow(view);
+        this.startAnimation();
+    }
+    /** 标记视图已更新，按帧节流合并重绘（高频增量不闪烁） */
+    render(view) {
+        this.view = view;
+        if (this.ended)
+            return;
+        this.dirty = true;
+        if (this.timer)
+            return;
+        this.timer = setTimeout(() => {
+            this.timer = null;
+            if (this.dirty && !this.ended) {
+                this.dirty = false;
+                this.renderNow(this.view);
+            }
+        }, this.frameMs);
+    }
+    /** 强制立即重绘（工具结果、终态等低频率但需及时反馈的事件） */
+    flush() {
+        if (this.timer) {
+            clearTimeout(this.timer);
+            this.timer = null;
+        }
+        if (this.ended)
+            return;
+        this.dirty = false;
+        this.renderNow(this.view);
+    }
+    /** 结束一轮：定型终态区块（留在屏幕上），恢复光标，停止动画 */
+    end(view) {
+        if (this.timer) {
+            clearTimeout(this.timer);
+            this.timer = null;
+        }
+        this.stopAnimation();
+        this.ended = true;
+        this.renderNow(view);
+        this.out.write(SHOW_CURSOR);
+    }
+    /** 兜底清理：清除未决定时器并恢复光标 */
+    dispose() {
+        if (this.timer) {
+            clearTimeout(this.timer);
+            this.timer = null;
+        }
+        this.stopAnimation();
+        if (!this.ended) {
+            this.out.write(SHOW_CURSOR);
+        }
+    }
+    startAnimation() {
+        if (this.animMs <= 0 || this.animTimer)
+            return;
+        this.animTimer = setInterval(() => {
+            this.animFrame++;
+            // 终态（done/stopped/error）由 end() 停止；此处兜底跳过，避免结束后还在重绘
+            if (this.ended || this.view.status !== "generating")
+                return;
+            // 无新事件也持续重绘，点号动画让静止期（思考/工具运行中）也有动态感
+            this.renderNow(this.view);
+        }, this.animMs);
+        this.animTimer.unref?.();
+    }
+    stopAnimation() {
+        if (this.animTimer) {
+            clearInterval(this.animTimer);
+            this.animTimer = null;
+        }
+    }
+    renderNow(view) {
+        const width = this.out.columns && this.out.columns > 0 ? this.out.columns : 80;
+        const lines = buildBlockLines(this.applyAnimation(view), width, this.maxBodyLines, this.maxBodyChars);
+        const newLines = lines.length;
+        if (this.blockLines > 0) {
+            // 关键：光标此刻停在区块【最后一行】行尾，回到区块第一行只需上移
+            // blockLines - 1 行。上移 blockLines 行会每帧多上移 1 行，把区块上方
+            // 的历史内容逐行"吃掉"（用户看到的"一行一行往上吃"）。
+            this.out.write(`\x1b[${this.blockLines - 1}A`);
+            this.out.write("\r");
+        }
+        for (let i = 0; i < lines.length; i++) {
+            this.out.write(`\r\x1b[2K${lines[i]}`);
+            if (i < lines.length - 1) {
+                this.out.write("\n");
+            }
+        }
+        if (newLines < this.blockLines) {
+            // 新区块比旧区块短：清掉下方多出的行
+            this.out.write("\n");
+            for (let i = 0; i < this.blockLines - newLines; i++) {
+                this.out.write("\x1b[2K\n");
+            }
+        }
+        this.out.write("\x1b[J");
+        this.blockLines = newLines;
+    }
+    /** 生成中阶段在标题后叠加心跳点号动画；终态原样返回（buildBlockLines 保持纯函数可测） */
+    applyAnimation(view) {
+        if (view.status !== "generating")
+            return view;
+        const base = view.headerTitle.replace(/\.\.\.\s*$/, "").trim();
+        const dots = ANIM_FRAMES[this.animFrame % ANIM_FRAMES.length];
+        return { ...view, headerTitle: `${base} ${dots}` };
+    }
+}

package/dist/src/progress/view.js

@@ -0,0 +1,30 @@
+/**
+ * progress/view.ts — 平台无关的"过程进度"视图模型
+ *
+ * 这是飞书过程卡片与终端过程区块共享的唯一数据模型：
+ *  - 飞书：buildProgressCard(view) 把 ProgressView 渲染为卡片 JSON
+ *  - 终端：TerminalProgressRenderer 把 ProgressView 渲染为 ANSI 区块
+ *  - 事件流：reduceProgress(prev, event) 把 ChatEvent 增量合并进 ProgressView
+ *
+ * 语义与飞书卡片对齐：
+ *  - headerTitle 是"生成中"阶段展示的标题（如"正在启动 Agent · 0秒"）
+ *  - status 决定终态外观（完成 / 已停止 / 异常结束）
+ *  - text 是正文累积（对应卡片 main_content / 终端区块正文）
+ *  - tools 是本轮工具调用列表（飞书卡片暂不展示，终端折叠为单行）
+ */
+/** 创建 ProgressView，未提供的字段使用与飞书 buildProgressCard 一致的默认值 */
+export function progressView(init = {}) {
+    return {
+        status: init.status ?? "generating",
+        headerTitle: init.headerTitle ?? "生成中...",
+        headerTemplate: init.headerTemplate ?? "blue",
+        text: init.text ?? "",
+        tools: init.tools ?? [],
+        showStop: init.showStop ?? true,
+        updatedAt: Date.now(),
+    };
+}
+/** 只读浅拷贝并覆盖部分字段，返回新视图（reducer 的不可变更新用） */
+export function withProgressView(prev, patch) {
+    return { ...prev, ...patch, updatedAt: Date.now() };
+}

package/dist/src/response-stall.js

@@ -0,0 +1,14 @@
+/**
+ * Tracks how long the displayed output character count has remained unchanged.
+ * Leaving a monitored phase clears the window; returning starts a fresh one.
+ */
+export function observeResponseProgress(previous, isMonitoredPhase, totalChars, now = Date.now()) {
+    if (!isMonitoredPhase)
+        return undefined;
+    if (previous?.totalChars === totalChars)
+        return previous;
+    return { totalChars, unchangedSince: now };
+}
+export function hasResponseStalled(observation, now, timeoutMs) {
+    return observation !== undefined && now - observation.unchangedSince >= timeoutMs;
+}

package/dist/src/runtime-entry.js

@@ -0,0 +1,13 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+/** Use compiled JavaScript in installed packages, with a tsx fallback for source checkouts. */
+export function resolveChatCccRuntimeSpawnSpec(projectRoot) {
+    const compiledEntry = join(projectRoot, "dist", "src", "index.js");
+    if (existsSync(compiledEntry)) {
+        return { command: process.execPath, args: [compiledEntry] };
+    }
+    return {
+        command: process.execPath,
+        args: [join(projectRoot, "node_modules", "tsx", "dist", "cli.mjs"), "src/index.ts"],
+    };
+}

package/dist/src/runtime-reload.js

@@ -0,0 +1,19 @@
+import { APP_ID, CONFIG_FILE, maskAppId, reloadConfigFromDisk, resolveDefaultAgentTool, } from "./config.js";
+import { appendStartupTrace } from "./shared.js";
+import { clearAdapterCache } from "./session.js";
+import { startChromeDevtoolsGuard } from "./chrome-devtools-guard.js";
+export function reloadRuntimeConfig(source) {
+    reloadConfigFromDisk();
+    clearAdapterCache();
+    startChromeDevtoolsGuard();
+    const result = {
+        configPath: CONFIG_FILE,
+        defaultAgent: resolveDefaultAgentTool(),
+        reloadedAt: new Date().toISOString(),
+    };
+    appendStartupTrace(`${source}: config reloaded`, {
+        appIdMask: maskAppId(APP_ID),
+        defaultAgent: result.defaultAgent,
+    });
+    return result;
+}