chatccc 0.2.252 → 0.2.254

package/src/agent-activity.ts

@@ -1,175 +0,0 @@
-import type { UnifiedBlock } from "./adapters/adapter-interface.ts";
-
-export type AgentActivityKind =
-  | "starting"
-  | "thinking"
-  | "tool"
-  | "processing"
-  | "responding"
-  | "searching"
-  | "compacting";
-
-/** The user-visible activity of a running Agent turn. */
-export interface AgentActivity {
-  kind: AgentActivityKind;
-  /** Time when the current activity began, used for truthful elapsed time. */
-  startedAt: number;
-  toolName?: string;
-  toolCount?: number;
-}
-
-interface ActiveTool {
-  id: string;
-  name: string;
-  startedAt: number;
-}
-
-export interface AgentActivityTracker {
-  activity: AgentActivity;
-  activeTools: Map<string, ActiveTool>;
-  nextAnonymousToolId: number;
-}
-
-export function createAgentActivityTracker(now = Date.now()): AgentActivityTracker {
-  return {
-    activity: { kind: "starting", startedAt: now },
-    activeTools: new Map(),
-    nextAnonymousToolId: 1,
-  };
-}
-
-function sameVisibleActivity(left: AgentActivity, right: AgentActivity): boolean {
-  return left.kind === right.kind
-    && left.toolName === right.toolName
-    && left.toolCount === right.toolCount;
-}
-
-function setActivity(tracker: AgentActivityTracker, next: AgentActivity): boolean {
-  if (sameVisibleActivity(tracker.activity, next)) return false;
-  tracker.activity = next;
-  return true;
-}
-
-function refreshToolActivity(tracker: AgentActivityTracker): boolean {
-  const tools = [...tracker.activeTools.values()];
-  const first = tools[0];
-  if (!first) return false;
-  return setActivity(tracker, {
-    kind: "tool",
-    startedAt: first.startedAt,
-    toolName: first.name,
-    toolCount: tools.length,
-  });
-}
-
-function removeCompletedTool(tracker: AgentActivityTracker, toolUseId: string): void {
-  if (toolUseId && tracker.activeTools.delete(toolUseId)) return;
-
-  // Older adapters did not always include a tool ID. Prefer an anonymous entry;
-  // if there is only one active call, it is still safe to match that result.
-  const anonymousId = [...tracker.activeTools.keys()].find((id) => id.startsWith("anonymous:"));
-  if (anonymousId) {
-    tracker.activeTools.delete(anonymousId);
-  } else if (tracker.activeTools.size === 1) {
-    const onlyId = tracker.activeTools.keys().next().value as string | undefined;
-    if (onlyId) tracker.activeTools.delete(onlyId);
-  }
-}
-
-/**
- * Applies one normalized Agent event and returns whether the persisted activity
- * changed. Tool activity takes precedence while a tool call is still active.
- */
-export function updateAgentActivity(
-  tracker: AgentActivityTracker,
-  block: UnifiedBlock,
-  now = Date.now(),
-): boolean {
-  if (block.type === "tool_use") {
-    const id = block.id || `anonymous:${tracker.nextAnonymousToolId++}`;
-    const existing = tracker.activeTools.get(id);
-    tracker.activeTools.set(id, {
-      id,
-      name: block.name || "未知工具",
-      startedAt: existing?.startedAt ?? now,
-    });
-    return refreshToolActivity(tracker);
-  }
-
-  if (block.type === "tool_result") {
-    removeCompletedTool(tracker, block.tool_use_id);
-    if (tracker.activeTools.size > 0) return refreshToolActivity(tracker);
-    return setActivity(tracker, { kind: "processing", startedAt: now });
-  }
-
-  if (tracker.activeTools.size > 0) return false;
-
-  switch (block.type) {
-    case "agent_status":
-      return setActivity(tracker, {
-        kind: block.status === "compacting" ? "compacting" : "responding",
-        startedAt: now,
-      });
-    case "thinking":
-    case "redacted_thinking":
-      return setActivity(tracker, { kind: "thinking", startedAt: now });
-    case "text":
-    case "text_final":
-      return setActivity(tracker, { kind: "responding", startedAt: now });
-    case "search_result":
-      return setActivity(tracker, { kind: "searching", startedAt: now });
-    case "compact_boundary":
-      return setActivity(tracker, { kind: "compacting", startedAt: now });
-  }
-}
-
-function formatElapsed(startedAt: number, now: number): string {
-  const totalSeconds = Math.max(0, Math.floor((now - startedAt) / 1000));
-  if (totalSeconds < 60) return `${totalSeconds}秒`;
-  const totalMinutes = Math.floor(totalSeconds / 60);
-  const seconds = totalSeconds % 60;
-  if (totalMinutes < 60) return `${totalMinutes}分${seconds}秒`;
-  const hours = Math.floor(totalMinutes / 60);
-  const minutes = totalMinutes % 60;
-  return `${hours}小时${minutes}分`;
-}
-
-function displayToolName(name: string | undefined): string {
-  const normalized = (name || "未知工具").replace(/\s+/g, " ").trim();
-  return normalized.length > 24 ? `${normalized.slice(0, 23)}…` : normalized;
-}
-
-export function formatAgentActivityTitle(
-  activity: AgentActivity | undefined,
-  now = Date.now(),
-): string {
-  if (!activity) return "正在处理";
-
-  let label: string;
-  switch (activity.kind) {
-    case "starting":
-      label = "正在启动 Agent";
-      break;
-    case "thinking":
-      label = "思考中";
-      break;
-    case "tool": {
-      const count = Math.max(1, activity.toolCount ?? 1);
-      label = `正在执行 ${displayToolName(activity.toolName)}${count > 1 ? ` 等 ${count} 项` : ""}`;
-      break;
-    }
-    case "processing":
-      label = "正在处理工具结果";
-      break;
-    case "responding":
-      label = "正在生成回复";
-      break;
-    case "searching":
-      label = "正在处理搜索结果";
-      break;
-    case "compacting":
-      label = "正在整理上下文";
-      break;
-  }
-  return `${label} · ${formatElapsed(activity.startedAt, now)}`;
-}

package/src/agent-delegate-task-rpc.ts

@@ -1,153 +0,0 @@
-import type { IncomingMessage, ServerResponse } from "node:http";
-import { resolve } from "node:path";
-
-import { resolveDefaultAgentTool } from "./config.ts";
-import { readUtf8JsonBody } from "./agent-rpc-body.ts";
-import { delegateAgentTask } from "./agent-delegate-task.ts";
-import type { PlatformAdapter } from "./platform-adapter.ts";
-import { applySharedPrefix } from "./shared-prefix.ts";
-
-export const AGENT_DELEGATE_TASK_PATH = "/api/agent/delegate-task";
-
-const MAX_REQUEST_BYTES = 128 * 1024;
-const VALID_TOOLS = new Set(["claude", "cursor", "codex"]);
-
-interface AgentDelegateTaskPayload {
-  tool?: unknown;
-  cwd?: unknown;
-  prompt?: unknown;
-  text?: unknown;
-  message?: unknown;
-  open_id?: unknown;
-  open_ids?: unknown;
-  openIds?: unknown;
-  chat_name?: unknown;
-}
-
-function jsonReply(res: ServerResponse, status: number, data: unknown): void {
-  res.writeHead(status, { "Content-Type": "application/json; charset=utf-8" });
-  res.end(JSON.stringify(data));
-}
-
-function stringValue(value: unknown): string {
-  return typeof value === "string" ? value.trim() : "";
-}
-
-function normalizeOpenIds(payload: AgentDelegateTaskPayload): string[] {
-  const explicitOpenId = stringValue(payload.open_id);
-  if (explicitOpenId) return [explicitOpenId];
-
-  const rawOpenIds = Array.isArray(payload.open_ids) ? payload.open_ids : payload.openIds;
-  if (!Array.isArray(rawOpenIds)) return [];
-  return rawOpenIds
-    .filter((item): item is string => typeof item === "string")
-    .map((item) => item.trim())
-    .filter(Boolean);
-}
-
-function promptFromPayload(payload: AgentDelegateTaskPayload): string {
-  return stringValue(payload.prompt) || stringValue(payload.text) || stringValue(payload.message);
-}
-
-function validateTool(rawTool: unknown): string {
-  const tool = stringValue(rawTool).toLowerCase() || resolveDefaultAgentTool();
-  if (!VALID_TOOLS.has(tool)) throw new Error(`unsupported tool: ${tool}`);
-  return tool;
-}
-
-function validateCwd(rawCwd: unknown): string {
-  const cwd = stringValue(rawCwd);
-  if (!cwd) throw new Error("cwd must be a non-empty string");
-  return resolve(cwd);
-}
-
-export async function handleAgentDelegateTaskRequest(
-  req: IncomingMessage,
-  res: ServerResponse,
-  platform: PlatformAdapter,
-): Promise<boolean> {
-  const url = new URL(req.url ?? "/", "http://127.0.0.1");
-  if (url.pathname !== AGENT_DELEGATE_TASK_PATH) return false;
-
-  if (req.method !== "POST") {
-    jsonReply(res, 405, { ok: false, error: "Method not allowed" });
-    return true;
-  }
-
-  if (platform.kind !== "feishu") {
-    jsonReply(res, 409, { ok: false, error: "This endpoint currently only supports Feishu." });
-    return true;
-  }
-
-  let payload: AgentDelegateTaskPayload;
-  try {
-    payload = await readUtf8JsonBody(req, MAX_REQUEST_BYTES);
-  } catch (err) {
-    jsonReply(res, 400, { ok: false, error: (err as Error).message || "Invalid JSON" });
-    return true;
-  }
-
-  let tool: string;
-  let cwd: string;
-  let promptText: string;
-  let promptNamePrefix: string;
-  let openIds: string[];
-  try {
-    tool = validateTool(payload.tool);
-    cwd = validateCwd(payload.cwd);
-    const rawPrompt = promptFromPayload(payload);
-    if (!rawPrompt) throw new Error("prompt must be a non-empty string");
-    const sharedPrefix = applySharedPrefix(rawPrompt);
-    promptText = sharedPrefix.text;
-    promptNamePrefix = sharedPrefix.body || rawPrompt;
-    openIds = normalizeOpenIds(payload);
-    if (openIds.length === 0) throw new Error("open_id or openIds must include at least one user");
-  } catch (err) {
-    jsonReply(res, 400, { ok: false, error: (err as Error).message });
-    return true;
-  }
-
-  try {
-    const result = await delegateAgentTask({
-      platform,
-      tool,
-      cwd,
-      promptText,
-      openIds,
-      chatNamePrefix: stringValue(payload.chat_name) || promptNamePrefix.slice(0, 10),
-    });
-    jsonReply(res, 200, {
-      ok: true,
-      chat_id: result.chatId,
-      session_id: result.sessionId,
-      tool: result.tool,
-      cwd: result.cwd,
-    });
-  } catch (err) {
-    jsonReply(res, 500, { ok: false, error: (err as Error).message });
-  }
-  return true;
-}
-
-export function buildAgentDelegateTaskCapabilityPrompt(input: { url: string; cwd?: string }): string {
-  const lines = [
-    "[ChatCCC local capability: delegate task]",
-    "You can create a separate Feishu ChatCCC agent session and assign its first task by calling this local endpoint.",
-    "",
-    `POST ${input.url}`,
-    "Content-Type: application/json; charset=utf-8",
-    "",
-    'Body: {"tool":"codex|claude|cursor","cwd":"absolute working directory","open_id":"Feishu open_id to invite","prompt":"first task text"}',
-    "",
-    "Rules:",
-    "- Use this only when the user asks you to start a separate delegated conversation/session.",
-    "- Pass cwd explicitly as an absolute local path.",
-    "- Pass tool explicitly when the user specified a target agent.",
-    "- Use open_id for one user or open_ids/openIds for multiple users.",
-    "- The prompt is sent through the normal ChatCCC prompt path, so project prompt injection and IM skills still apply.",
-    "- Request body must be UTF-8 encoded JSON bytes. Do not call Feishu Open Platform directly.",
-    "[/ChatCCC local capability: delegate task]",
-  ];
-  if (input.cwd) lines.splice(2, 0, `Current working directory: ${input.cwd}`);
-  return lines.join("\n");
-}

package/src/agent-delegate-task.ts

@@ -1,91 +0,0 @@
-import { resolve } from "node:path";
-
-import { sessionPrefixForTool, toolDisplayName, ts } from "./config.ts";
-import { setDefaultCwd } from "./config.ts";
-import type { PlatformAdapter } from "./platform-adapter.ts";
-import {
-  getEffectiveFastModeForTool,
-  initClaudeSession,
-  recordSessionRegistry,
-  resumeAndPrompt,
-  saveSessionTool,
-} from "./session.ts";
-import { bindChatToSession } from "./session-chat-binding.ts";
-import { sessionChatName } from "./session-name.ts";
-
-export interface DelegateAgentTaskInput {
-  platform: PlatformAdapter;
-  tool: string;
-  cwd: string;
-  promptText: string;
-  openIds: string[];
-  chatNamePrefix?: string;
-  msgTimestamp?: number;
-  traceId?: string;
-}
-
-export interface DelegateAgentTaskResult {
-  chatId: string;
-  sessionId: string;
-  tool: string;
-  cwd: string;
-}
-
-export async function delegateAgentTask(input: DelegateAgentTaskInput): Promise<DelegateAgentTaskResult> {
-  const cwd = resolve(input.cwd);
-  const toolLabel = toolDisplayName(input.tool);
-  const init = await initClaudeSession(input.tool, cwd);
-  const sessionId = init.sessionId;
-  const chatNamePrefix = input.chatNamePrefix?.trim() || input.promptText.slice(0, 10) || "新会话";
-  const chatName = sessionChatName(chatNamePrefix, cwd);
-
-  let chatId: string;
-  try {
-    chatId = await input.platform.createGroup(chatName, input.openIds);
-    await input.platform.updateChatInfo(chatId, chatName, `${sessionPrefixForTool(input.tool)} ${sessionId}`);
-    await setDefaultCwd(cwd, chatId);
-    bindChatToSession(sessionId, chatId);
-    await recordSessionRegistry({
-      chatId,
-      sessionId,
-      tool: input.tool,
-      chatType: "group",
-      chatName,
-      turnCount: 0,
-      startTime: Date.now(),
-      running: false,
-    });
-    await saveSessionTool(sessionId, input.tool, chatName);
-  } catch (err) {
-    console.error(`[${ts()}] [AGENT-DELEGATE-TASK] create group failed: ${(err as Error).message}`);
-    throw err;
-  }
-
-  await input.platform.sendCard(
-    chatId,
-    `${toolLabel} Session Ready`,
-    `已创建 **${toolLabel}** 会话群。\n\n` +
-      `**Session ID:** ${sessionId}\n` +
-      `**工作目录:** \`${cwd}\`\n\n` +
-      `下面会自动把任务作为第一句话发送给 ${toolLabel}。`,
-    "green",
-  ).catch(() => {});
-  const fastMode = getEffectiveFastModeForTool(input.tool, sessionId);
-  const avatarUpdate = fastMode
-    ? input.platform.setChatAvatar(chatId, input.tool, "new", { fastMode: true })
-    : input.platform.setChatAvatar(chatId, input.tool, "new");
-  avatarUpdate.catch(() => {});
-
-  await resumeAndPrompt(
-    sessionId,
-    input.promptText,
-    input.platform,
-    chatId,
-    input.msgTimestamp ?? Date.now(),
-    input.tool,
-    input.traceId,
-  );
-
-  console.log(`[${ts()}] [AGENT-DELEGATE-TASK] created ${toolLabel} session=${sessionId} chat=${chatId} cwd=${cwd}`);
-  return { chatId, sessionId, tool: input.tool, cwd };
-}

package/src/agent-file-rpc.ts

@@ -1,172 +0,0 @@
-import type { IncomingMessage, ServerResponse } from "node:http";
-import { extname, isAbsolute, resolve } from "node:path";
-import { stat } from "node:fs/promises";
-
-import { getTenantAccessToken, sendFileReply, sendTextReply } from "./feishu-platform.ts";
-import { ts, resolveDefaultAgentTool } from "./config.ts";
-import { readUtf8JsonBody } from "./agent-rpc-body.ts";
-import { getAdapterForTool } from "./session.ts";
-import { getChatsForSession } from "./session-chat-binding.ts";
-import { splitFeishuTargetChats } from "./agent-platform-routing.ts";
-
-export const AGENT_SEND_FILE_PATH = "/api/agent/send-file";
-
-const MAX_REQUEST_BYTES = 64 * 1024;
-const MAX_FILE_BYTES = 100 * 1024 * 1024;
-const ALLOWED_FILE_EXTS = new Set([
-  ".mp4", ".mov", ".avi", ".mkv", ".webm", ".flv",
-  ".mp3", ".wav", ".ogg", ".aac", ".m4a",
-  ".pdf", ".doc", ".docx", ".xls", ".xlsx", ".csv", ".ppt", ".pptx",
-  ".txt", ".zip", ".tar", ".gz",
-]);
-
-function jsonReply(res: ServerResponse, status: number, data: unknown): void {
-  res.writeHead(status, { "Content-Type": "application/json; charset=utf-8" });
-  res.end(JSON.stringify(data));
-}
-
-async function resolveAndValidateFilePath(cwd: string, rawPath: unknown): Promise<string> {
-  if (typeof rawPath !== "string" || rawPath.trim() === "") {
-    throw new Error("path must be a non-empty string");
-  }
-
-  const sessionRoot = resolve(cwd);
-  const filePath = isAbsolute(rawPath)
-    ? resolve(rawPath)
-    : resolve(sessionRoot, rawPath);
-
-  const ext = extname(filePath).toLowerCase();
-  if (!ALLOWED_FILE_EXTS.has(ext)) {
-    throw new Error(`unsupported file extension: ${ext || "(none)"}`);
-  }
-
-  const st = await stat(filePath);
-  if (!st.isFile()) throw new Error("file path is not a file");
-  if (st.size <= 0) throw new Error("file is empty");
-  if (st.size > MAX_FILE_BYTES) throw new Error("file is larger than 100MB");
-  return filePath;
-}
-
-export async function handleAgentFileRequest(
-  req: IncomingMessage,
-  res: ServerResponse,
-): Promise<boolean> {
-  const url = new URL(req.url ?? "/", "http://127.0.0.1");
-  if (url.pathname !== AGENT_SEND_FILE_PATH) return false;
-
-  if (req.method !== "POST") {
-    jsonReply(res, 405, { ok: false, error: "Method not allowed" });
-    return true;
-  }
-
-  let payload: { session_id?: unknown; path?: unknown; caption?: unknown };
-  try {
-    payload = await readUtf8JsonBody(req, MAX_REQUEST_BYTES);
-  } catch (err) {
-    jsonReply(res, 400, { ok: false, error: (err as Error).message || "Invalid JSON" });
-    return true;
-  }
-
-  const sessionId = typeof payload.session_id === "string" ? payload.session_id : "";
-  if (!sessionId) {
-    jsonReply(res, 400, { ok: false, error: "Missing session_id" });
-    return true;
-  }
-
-  let cwd: string;
-  try {
-    const { getSessionTool } = await import("./session.ts");
-    const tool = await getSessionTool(sessionId);
-    const adapter = getAdapterForTool(tool ?? resolveDefaultAgentTool());
-    const info = await adapter.getSessionInfo(sessionId);
-    if (!info?.cwd) {
-      jsonReply(res, 400, { ok: false, error: "Cannot determine cwd for session" });
-      return true;
-    }
-    cwd = info.cwd;
-  } catch (err) {
-    jsonReply(res, 500, { ok: false, error: `Failed to get session info: ${(err as Error).message}` });
-    return true;
-  }
-
-  let filePath: string;
-  try {
-    filePath = await resolveAndValidateFilePath(cwd, payload.path);
-  } catch (err) {
-    jsonReply(res, 400, { ok: false, error: (err as Error).message });
-    return true;
-  }
-
-  const chatIds = getChatsForSession(sessionId);
-  if (chatIds.length === 0) {
-    jsonReply(res, 404, { ok: false, error: "No chats bound to this session" });
-    return true;
-  }
-
-  const { getPlatformForChat } = await import("./session.ts");
-  const { targetChatIds, skippedUnsupported } = splitFeishuTargetChats(
-    chatIds,
-    (cid) => getPlatformForChat(cid)?.kind,
-  );
-  if (targetChatIds.length === 0) {
-    jsonReply(res, 409, {
-      ok: false,
-      error: "This endpoint only sends to Feishu chats. The bound chats are WeChat chats; use the WeChat file or video helper script instead.",
-      skippedUnsupported,
-    });
-    return true;
-  }
-
-  try {
-    const token = await getTenantAccessToken();
-    const caption = typeof payload.caption === "string" ? payload.caption.trim() : "";
-    let sentCount = 0;
-    for (const cid of targetChatIds) {
-      try {
-        await sendFileReply(token, cid, filePath);
-        if (caption) await sendTextReply(token, cid, caption);
-        sentCount++;
-      } catch (err) {
-        console.error(`[${ts()}] [AGENT-FILE] send to ${cid} failed: ${(err as Error).message}`);
-      }
-    }
-    console.log(`[${ts()}] [AGENT-FILE] sent file to ${sentCount}/${targetChatIds.length} Feishu chats, session=${sessionId} path=${filePath} skippedUnsupported=${skippedUnsupported.length}`);
-    jsonReply(res, 200, { ok: true, sentTo: sentCount, total: targetChatIds.length, skippedUnsupported });
-  } catch (err) {
-    console.error(`[${ts()}] [AGENT-FILE] send failed: ${(err as Error).message}`);
-    jsonReply(res, 500, { ok: false, error: (err as Error).message });
-  }
-  return true;
-}
-
-// ---------------------------------------------------------------------------
-// 兼容旧版 buildAgentFileCapabilityPrompt（供 im-skills 使用）
-// ---------------------------------------------------------------------------
-
-export function buildAgentFileCapabilityPrompt(input: {
-  url: string;
-  sessionId?: string;
-  cwd?: string;
-}): string {
-  const lines = [
-    "[ChatCCC local capability: send file]",
-    "You can send a file (video, audio, document, etc.) to all chats bound to this session by calling this local endpoint.",
-    "",
-    `POST ${input.url}`,
-    "Content-Type: application/json; charset=utf-8",
-    "",
-    `Body: {"session_id":"${input.sessionId ?? "YOUR_SESSION_ID"}","path":"absolute file path","caption":"optional caption"}`,
-    "",
-    "Rules:",
-    "- Save or choose a local file first, then call the endpoint.",
-    "- Use an absolute local file path. Do not call Feishu Open Platform directly.",
-    "- Request body must be UTF-8 encoded JSON bytes; caption supports Unicode text, including Chinese.",
-    "- Only call this endpoint when the user asked for a file/video or when a file is useful to the answer.",
-    "- Max file size: 100MB.",
-    "[/ChatCCC local capability: send file]",
-  ];
-  if (input.cwd) {
-    lines.splice(2, 0, `Current working directory: ${input.cwd}`);
-  }
-  return lines.join("\n");
-}