chatccc 0.2.252 → 0.2.254

package/deepccc-agent/src/permissions.ts

@@ -1,226 +0,0 @@
-import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { DEEPCCC_HOME } from "./config.js";
-
-// ---------------------------------------------------------------------------
-// 权限机制：仅拦截有副作用的工具（run_command / edit_file / create_file /
-// delete_file / move_file / apply_patch）。只读工具永不拦截。
-//
-// 三种信任粒度：
-//   - 允许一次（y）：本次操作放行
-//   - 永远允许（a）：写入 ~/.deepccc/allow.json，之后按规则自动放行
-//   - 本会话允许所有（g）：当前 ChatSession 内全部放行（不落盘）
-//   - 拒绝（n）：本次拦截
-//
-// 判定顺序（PermissionGate.check）：
-//   1. mode === "bypass"（--dangerously-bypass-permissions）→ 全部放行
-//   2. 本会话已"允许所有" → 放行
-//   3. deny 规则命中 → 拒绝
-//   4. allow 规则命中 → 放行（覆盖高危判定）
-//   5. 仅 run_command 命中内置危险命令库时才进入询问流程；
-//      无交互 resolver（非 TTY / JSONL / 程序化调用）时高危自动拒绝。
-//      文件编辑等常规操作默认放行（不打断工作流）。
-// ---------------------------------------------------------------------------
-
-export type PermissionMode = "ask" | "bypass";
-export type PermissionReason = "high-risk" | "rule";
-export type PermissionAnswer = "allow" | "allow-always" | "allow-session" | "deny";
-export type PermissionDecision = "allow" | "deny";
-
-export interface PermissionRequest {
-  /** 工具名：run_command / edit_file / create_file / delete_file / move_file / apply_patch */
-  tool: string;
-  /** 具体操作：命令全文或文件路径 */
-  action: string;
-  /** high-risk = 命中内置危险命令库，需要询问；rule = 仅受 allow/deny 规则管控 */
-  reason: PermissionReason;
-  /** 展示给用户的说明 */
-  detail: string;
-  /** 额外匹配键（如文件相对路径），allow/deny 规则命中任一即生效 */
-  altKeys?: string[];
-}
-
-/** ask 模式下高危操作的交互确认回调（由 CLI 注入 readline 实现） */
-export type PermissionResolver = (request: PermissionRequest) => Promise<PermissionAnswer>;
-
-export interface AllowRules {
-  /** 永远允许的规则，格式 "<tool>:<pattern>" 或 "*:<pattern>"，pattern 中 * 为通配符 */
-  allow: string[];
-  /** 永远拒绝的规则，格式同上 */
-  deny: string[];
-}
-
-const RULES_FILE = join(DEEPCCC_HOME, "allow.json");
-const EMPTY_RULES: AllowRules = { allow: [], deny: [] };
-
-/**
- * 内置危险命令库（命中即进入询问流程；allow 规则可覆盖）。
- * 覆盖 Windows 与 Unix 常见破坏性操作：强制删除、强制推送、磁盘/分区、
- * 关机重启、设备覆写、数据库 DROP、fork bomb、全局卸载、发布等。
- */
-const DANGEROUS_COMMAND_PATTERNS: RegExp[] = [
-  /^\s*rm\s+-[a-zA-Z]*r[a-zA-Z]*f[a-zA-Z]*\b/i, // rm -rf / rm -fr
-  /^\s*rm\s+-[a-zA-Z]*f[a-zA-Z]*r[a-zA-Z]*\b/i,
-  /^\s*rmdir\s+\/s/i, // Windows rmdir /s
-  /^\s*(del|erase)\s+\/s/i, // Windows del /s
-  /^\s*git\s+(push|fetch|pull)\s+.*(--force|-f\b)/i, // git push --force
-  /^\s*git\s+reset\s+--hard/i,
-  /^\s*git\s+clean\s+(-[a-z]*f)/i,
-  /^\s*format\s+[a-z]:/i,
-  /^\s*diskpart\b/i,
-  /^\s*(shutdown|reboot)\b/i,
-  /^\s*mkfs\b/i,
-  /^\s*fdisk\b/i,
-  /^\s*dd\s+.*\bof=/i,
-  /^\s*sudo\s+(rm|shutdown|mkfs|dd|fdisk|diskpart)/i,
-  /^\s*Remove-Item\s+-Recurse/i,
-  /^\s*:\(\)\s*\{.*\}\s*;/i, // fork bomb
-  /^\s*(drop|truncate)\s+table/i,
-  /^\s*npm\s+(publish|unpublish)\b/i,
-  /^\s*npm\s+uninstall\s+-g/i,
-  /^\s*pip\s+uninstall\b/i,
-];
-
-export function isDangerousCommand(command: string): boolean {
-  return DANGEROUS_COMMAND_PATTERNS.some((re) => re.test(command));
-}
-
-// ---------------------------------------------------------------------------
-// 规则加载（~/.deepccc/allow.json，热加载）
-// ---------------------------------------------------------------------------
-
-let rulesCache: AllowRules | null = null;
-let rulesStamp: string | null | undefined;
-
-function rulesFileStamp(): string | null {
-  if (!existsSync(RULES_FILE)) return null;
-  try {
-    const s = statSync(RULES_FILE);
-    return `${s.mtimeMs}:${s.size}`;
-  } catch {
-    return null;
-  }
-}
-
-function sanitizeRuleList(raw: unknown): string[] {
-  if (!Array.isArray(raw)) return [];
-  return raw.filter((item): item is string => typeof item === "string" && item.trim().length > 0);
-}
-
-function loadRules(): AllowRules {
-  if (!existsSync(RULES_FILE)) return EMPTY_RULES;
-  try {
-    const raw = readFileSync(RULES_FILE, "utf-8").replace(/^\uFEFF/, "");
-    const parsed = JSON.parse(raw);
-    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return EMPTY_RULES;
-    return {
-      allow: sanitizeRuleList((parsed as Record<string, unknown>).allow),
-      deny: sanitizeRuleList((parsed as Record<string, unknown>).deny),
-    };
-  } catch (err) {
-    console.error(`[PERMISSIONS] failed to read allow.json: ${(err as Error).message}`);
-    return EMPTY_RULES;
-  }
-}
-
-export function getAllowRules(): AllowRules {
-  const stamp = rulesFileStamp();
-  if (!rulesCache || stamp !== rulesStamp) {
-    rulesCache = loadRules();
-    rulesStamp = stamp;
-  }
-  return rulesCache;
-}
-
-export function reloadAllowRules(): void {
-  rulesCache = null;
-  rulesStamp = undefined;
-}
-
-/** 把"永远允许"的规则追加写入 allow.json 并热加载 */
-export function appendAllowRule(rule: string): void {
-  const rules = getAllowRules();
-  if (rules.allow.includes(rule)) return;
-  const next: AllowRules = { allow: [...rules.allow, rule], deny: rules.deny };
-  try {
-    mkdirSync(dirname(RULES_FILE), { recursive: true });
-    writeFileSync(RULES_FILE, `${JSON.stringify(next, null, 2)}\n`, "utf-8");
-    reloadAllowRules();
-  } catch (err) {
-    console.error(`[PERMISSIONS] failed to write allow.json: ${(err as Error).message}`);
-  }
-}
-
-function escapeRegex(s: string): string {
-  return s.replace(/[.+?^${}()|[\]\\]/g, "\\$&");
-}
-
-/**
- * 规则匹配。规则格式 "<tool>:<pattern>" 或 "*:<pattern>"；
- * pattern 中的 * 为通配符，其余字符按字面量匹配。
- */
-export function matchRule(rule: string, key: string): boolean {
-  const ruleColon = rule.indexOf(":");
-  if (ruleColon === -1) return false;
-  const toolPart = rule.slice(0, ruleColon);
-  const pattern = rule.slice(ruleColon + 1);
-
-  const keyColon = key.indexOf(":");
-  if (keyColon === -1) return false;
-  const keyTool = key.slice(0, keyColon);
-  const keyAction = key.slice(keyColon + 1);
-
-  if (toolPart !== "*" && toolPart !== keyTool) return false;
-  const re = new RegExp(`^${pattern.split("*").map(escapeRegex).join(".*")}$`);
-  return re.test(keyAction);
-}
-
-// ---------------------------------------------------------------------------
-// PermissionGate
-// ---------------------------------------------------------------------------
-
-export class PermissionGate {
-  private readonly mode: PermissionMode;
-  private readonly resolver?: PermissionResolver;
-  private sessionAllowAll = false;
-
-  constructor(mode: PermissionMode = "ask", resolver?: PermissionResolver) {
-    this.mode = mode;
-    this.resolver = resolver;
-  }
-
-  getMode(): PermissionMode {
-    return this.mode;
-  }
-
-  async check(request: PermissionRequest): Promise<PermissionDecision> {
-    if (this.mode === "bypass" || this.sessionAllowAll) return "allow";
-
-    const key = `${request.tool}:${request.action}`;
-    const keys = [key, ...(request.altKeys ?? []).map((k) => `${request.tool}:${k}`)];
-    const rules = getAllowRules();
-    if (rules.deny.some((r) => keys.some((k) => matchRule(r, k)))) return "deny";
-    if (rules.allow.some((r) => keys.some((k) => matchRule(r, k)))) return "allow";
-
-    // 只有命中内置危险命令库的 run_command 才询问；文件编辑等常规操作默认放行
-    if (request.reason !== "high-risk") return "allow";
-
-    // 高危且无交互能力（非 TTY / JSONL / 程序化调用）→ 安全默认拒绝
-    if (!this.resolver) return "deny";
-
-    const answer = await this.resolver(request);
-    switch (answer) {
-      case "allow":
-        return "allow";
-      case "allow-session":
-        this.sessionAllowAll = true;
-        return "allow";
-      case "allow-always":
-        appendAllowRule(key);
-        return "allow";
-      case "deny":
-      default:
-        return "deny";
-    }
-  }
-}

package/deepccc-agent/src/privacy.ts

@@ -1,141 +0,0 @@
-import { existsSync, readFileSync, statSync } from "node:fs";
-import { join } from "node:path";
-import { DEEPCCC_HOME } from "./config.js";
-
-interface PrivacyRules {
-  [key: string]: string;
-}
-
-interface PrivacyConfig {
-  enabled: boolean;
-  rules: PrivacyRules;
-}
-
-let config: PrivacyConfig | null = null;
-let loadedStamp: string | null | undefined;
-
-function privacyFilePath(): string {
-  return join(DEEPCCC_HOME, "privacy.json");
-}
-
-function privacyFileStamp(): string | null {
-  const filePath = privacyFilePath();
-  if (!existsSync(filePath)) return null;
-  try {
-    const s = statSync(filePath);
-    return `${s.mtimeMs}:${s.size}`;
-  } catch {
-    return null;
-  }
-}
-
-function sanitizeRules(raw: Record<string, unknown>): PrivacyRules {
-  const result: PrivacyRules = {};
-  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: Record<string, unknown>): PrivacyConfig {
-  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 as Record<string, unknown>) };
-}
-
-function loadConfig(): PrivacyConfig {
-  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 as Record<string, unknown>);
-  } catch (err) {
-    console.error(`[PRIVACY] failed to read privacy.json: ${(err as Error).message}`);
-    return { enabled: true, rules: {} };
-  }
-}
-
-export function getPrivacyConfig(): PrivacyConfig {
-  const stamp = privacyFileStamp();
-  if (!config || stamp !== loadedStamp) {
-    config = loadConfig();
-    loadedStamp = stamp;
-  }
-  return config;
-}
-
-export function getPrivacyRules(): PrivacyRules {
-  return getPrivacyConfig().rules;
-}
-
-export function reloadPrivacyRules(): void {
-  config = null;
-  loadedStamp = undefined;
-}
-
-/**
- * 把文本中的隐私规则字面量替换为掩码值（split+join，规则键保持字面量）。
- * 仅作用于展示层：调用方应保持内部数据（如持久化上下文）为原文。
- */
-export function applyPrivacy(text: string): string {
-  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)) {
-    result = result.split(from).join(to);
-  }
-  return result;
-}
-
-/**
- * 递归替换结构化数据（工具调用参数/结果）中的字符串字段。
- * 数组逐项、对象逐值、字符串走 applyPrivacy，其余类型原样返回。
- */
-export function applyPrivacyToJson(value: unknown): unknown {
-  const { enabled, rules } = getPrivacyConfig();
-  if (!enabled || Object.keys(rules).length === 0) return value;
-  if (typeof value === "string") return applyPrivacy(value);
-  if (Array.isArray(value)) return value.map((item) => applyPrivacyToJson(item));
-  if (value !== null && typeof value === "object") {
-    const out: Record<string, unknown> = {};
-    for (const [key, item] of Object.entries(value as Record<string, unknown>)) {
-      out[key] = applyPrivacyToJson(item);
-    }
-    return out;
-  }
-  return value;
-}

package/deepccc-agent/src/proc-tree-kill.ts

@@ -1,61 +0,0 @@
-import { spawn } from "node:child_process";
-
-/**
- * Best-effort process-tree termination.
- *
- * Commands are spawned through a platform shell, so the pid we get is often
- * the outer shell process. Killing only that process can leave the real child
- * command running. This helper targets the whole process tree on Windows and
- * the process group on POSIX when possible.
- */
-export async function killProcessTree(pid: number | undefined): Promise<void> {
-  if (pid == null || !Number.isFinite(pid) || pid <= 0) return;
-  if (process.platform === "win32") {
-    await killWindowsTree(pid);
-    return;
-  }
-  await killPosixTree(pid);
-}
-
-function killWindowsTree(pid: number): Promise<void> {
-  return new Promise<void>((resolve) => {
-    let resolved = false;
-    const done = () => {
-      if (resolved) return;
-      resolved = true;
-      resolve();
-    };
-
-    try {
-      const proc = spawn("taskkill", ["/pid", String(pid), "/T", "/F"], {
-        stdio: "ignore",
-        windowsHide: true,
-      });
-      proc.once("error", (err) => {
-        console.warn(`[killProcessTree] taskkill spawn error for pid=${pid}: ${(err as Error).message}`);
-        done();
-      });
-      proc.once("close", () => { done(); });
-      setTimeout(done, 3000).unref();
-    } catch (err) {
-      console.warn(`[killProcessTree] taskkill failed for pid=${pid}: ${(err as Error).message}`);
-      done();
-    }
-  });
-}
-
-async function killPosixTree(pid: number): Promise<void> {
-  trySignal(-pid, "SIGTERM");
-  trySignal(pid, "SIGTERM");
-  await new Promise((resolve) => setTimeout(resolve, 1000));
-  trySignal(-pid, "SIGKILL");
-  trySignal(pid, "SIGKILL");
-}
-
-function trySignal(target: number, signal: NodeJS.Signals): void {
-  try {
-    process.kill(target, signal);
-  } catch {
-    // Process is already gone or cannot be signaled.
-  }
-}

package/deepccc-agent/src/progress/cards-helpers.ts

@@ -1,76 +0,0 @@
-/**
- * progress/cards-helpers.ts — 从 ChatCCC cards.ts 提取的纯函数（DeepCCC 独立版）
- *
- * terminal-renderer 需要 getToolEmoji（工具 emoji 映射）和 truncateContent
- * （正文按行/字符截断）。DeepCCC 没有飞书卡片模块，这两个函数在此独立存放，
- * 与 ChatCCC 保持一致实现，避免引入整张卡片模块。
- */
-
-// 检测 markdown 代码块是否未闭合（``` 出现奇数次）
-export function isCodeBlockOpen(text: string): boolean {
-  const matches = text.match(/```/g);
-  return matches ? matches.length % 2 !== 0 : false;
-}
-
-export function truncateContent(text: string, maxLines = 20, maxChars = 8000): string {
-  const lines = text.split("\n");
-  // 跳过开头空行
-  let startIdx = 0;
-  while (startIdx < lines.length && lines[startIdx].trim() === "") {
-    startIdx++;
-  }
-  const effectiveLines = lines.slice(startIdx);
-  let displayText: string;
-  if (effectiveLines.length > maxLines) {
-    const firstLine = effectiveLines[0];
-    const lastLines = effectiveLines.slice(-(maxLines - 1)).join("\n");
-    displayText = firstLine + "\n...\n" + lastLines;
-  } else {
-    displayText = text;
-  }
-
-  // 截断后如果代码块未闭合，补上闭合标记，避免后续追加内容时误入代码块
-  if (isCodeBlockOpen(displayText)) {
-    displayText += "\n```";
-  }
-
-  return displayText;
-}
-
-const TOOL_EMOJI_MAP: Record<string, string> = {
-  Read: "\u{1F4D6}",          // 📖
-  Write: "\u{270D}\u{FE0F}",  // ✍️
-  Edit: "\u{270F}\u{FE0F}",   // ✏️
-  Grep: "\u{1F50E}",          // 🔎
-  Glob: "\u{1F4C2}",          // 📂
-  Bash: "\u{1F5A5}\u{FE0F}",  // 🖥️
-  WebSearch: "\u{1F310}",     // 🌐
-  WebFetch: "\u{1F4E5}",      // 📥
-  TodoWrite: "\u{2705}",      // ✅
-  Agent: "\u{1F916}",         // 🤖
-  NotebookEdit: "\u{1F4D3}",  // 📓
-  AskUserQuestion: "\u{2753}",// ❓
-  // CCC 内置 Agent 下划线命名（getToolEmoji 会先把下划线转驼峰再查表，这里保留蛇形条目以便直接命中）
-  read_file: "\u{1F4D6}",          // 📖
-  list_dir: "\u{1F4C2}",          // 📂
-  search_code: "\u{1F50E}",       // 🔎
-  run_command: "\u{1F5A5}\u{FE0F}", // 🖥️
-  edit_file: "\u{270F}\u{FE0F}",  // ✏️
-  create_file: "\u{270D}\u{FE0F}", // ✍️
-  delete_file: "\u{1F5D1}\u{FE0F}", // 🗑️
-  move_file: "\u{1F4E6}",         // 📦
-  apply_patch: "\u{1F4CB}",       // 📋
-};
-
-export function getToolEmoji(name: string): string {
-  return TOOL_EMOJI_MAP[name] ?? TOOL_EMOJI_MAP[normalizeToolName(name)] ?? "\u{1F527}"; // 🔧
-}
-
-/** 把下划线命名转成驼峰（read_file → ReadFile），用于兼容两种命名风格 */
-export function normalizeToolName(name: string): string {
-  return name
-    .split("_")
-    .filter((part) => part.length > 0)
-    .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
-    .join("");
-}

package/deepccc-agent/src/progress/reducer.ts

@@ -1,113 +0,0 @@
-/**
- * progress/reducer.ts — ChatEvent 事件流 → ProgressView 的增量合并
- *
- * 这是飞书与终端共享的唯一一份"事件 → 过程视图"公共逻辑：
- * 终端 REPL 直接消费 ChatSession.chat() 的事件流，逐条 reduce；
- * 飞书侧 display loop 若未来接入事件流，同样使用本 reducer，保证两端
- * 看到的过程状态（正文累积、工具调用、终态判定）完全一致。
- */
-
-import type { ChatEvent } from "../index.js";
-import {
-  withProgressView,
-  type ProgressToolCall,
-  type ProgressView,
-} from "./view.js";
-
-/** 工具调用 input 单行摘要（终端折叠行展示用） */
-export function summarizeToolInput(input: unknown, maxChars = 120): string {
-  let raw: string;
-  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: unknown, maxChars = 120): string {
-  let raw: string;
-  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: ProgressView, event: ChatEvent): ProgressView {
-  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: ProgressToolCall = {
-        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" as const) : ("ok" as const);
-      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;
-  }
-}