chatccc 0.2.45 → 0.2.47

package/im-skills/feishu-skill/receive-send-file.md

@@ -4,25 +4,17 @@
 
 Videos are sent as regular files (not media), which looks cleaner in Feishu.
 
-First, query the current send token:
-```bash
-curl "{{session_grants_url}}?sid={{session_id}}"
-```
-
-Then send with the returned url and token:
-
 ### Script (recommended)
 ```bash
-node "{{send_file_script}}" --url <url_from_query> --token <token_from_query> --path "<absolute file path>" --caption "<optional caption>"
+node "{{send_file_script}}" --url "{{send_file_url}}" --session-id "{{session_id}}" --path "<absolute file path>" --caption "<optional caption>"
 ```
 
 ### Direct HTTP
 ```http
-POST <url_from_query>
-Authorization: Bearer <token_from_query>
+POST {{send_file_url}}
 Content-Type: application/json; charset=utf-8
 
-{"path":"<absolute file path>","caption":"<optional caption>"}
+{"session_id":"{{session_id}}","path":"<absolute file path>","caption":"<optional caption>"}
 ```
 
 ### Rules

package/im-skills/feishu-skill/receive-send-image.md

@@ -2,25 +2,17 @@
 
 ## Send Images
 
-First, query the current send token:
-```bash
-curl "{{session_grants_url}}?sid={{session_id}}"
-```
-
-Then send with the returned url and token:
-
 ### Script (recommended)
 ```bash
-node "{{send_image_script}}" --url <url_from_query> --token <token_from_query> --path "<absolute image path>" --caption "<optional caption>"
+node "{{send_image_script}}" --url "{{send_image_url}}" --session-id "{{session_id}}" --path "<absolute image path>" --caption "<optional caption>"
 ```
 
 ### Direct HTTP
 ```http
-POST <url_from_query>
-Authorization: Bearer <token_from_query>
+POST {{send_image_url}}
 Content-Type: application/json; charset=utf-8
 
-{"path":"<absolute image path>","caption":"<optional caption>"}
+{"session_id":"{{session_id}}","path":"<absolute image path>","caption":"<optional caption>"}
 ```
 
 ### Rules

package/im-skills/feishu-skill/send-file.mjs

@@ -14,26 +14,25 @@ function parseArgs(argv) {
 
 function usage() {
   console.error(`Usage:
-  node ${basename(process.argv[1])} --url <url> --token <token> --path <absolute file path> [--caption <text>]`);
+  node ${basename(process.argv[1])} --url <url> --session-id <session_id> --path <absolute file path> [--caption <text>]`);
 }
 
 async function main() {
   const args = parseArgs(process.argv.slice(2));
   const url = args.url || process.env.CHATCCC_SEND_FILE_URL;
-  const token = args.token || process.env.CHATCCC_SEND_FILE_TOKEN;
+  const sessionId = args["session-id"] || args.session_id || process.env.CHATCCC_SESSION_ID;
   const path = args.path;
   const caption = args.caption || "";
 
-  if (!url || !token || !path) {
+  if (!url || !sessionId || !path) {
     usage();
     process.exit(1);
   }
 
-  const body = Buffer.from(JSON.stringify({ path, caption }), "utf8");
+  const body = Buffer.from(JSON.stringify({ session_id: sessionId, path, caption }), "utf8");
   const response = await fetch(url, {
     method: "POST",
     headers: {
-      Authorization: `Bearer ${token}`,
       "Content-Type": "application/json; charset=utf-8",
     },
     body,
@@ -49,4 +48,4 @@ async function main() {
 main().catch((err) => {
   console.error(err instanceof Error ? err.message : String(err));
   process.exit(1);
-});
+});

package/im-skills/feishu-skill/send-image.mjs

@@ -14,26 +14,25 @@ function parseArgs(argv) {
 
 function usage() {
   console.error(`Usage:
-  node ${basename(process.argv[1])} --url <url> --token <token> --path <absolute image path> [--caption <text>]`);
+  node ${basename(process.argv[1])} --url <url> --session-id <session_id> --path <absolute image path> [--caption <text>]`);
 }
 
 async function main() {
   const args = parseArgs(process.argv.slice(2));
   const url = args.url || process.env.CHATCCC_SEND_IMAGE_URL;
-  const token = args.token || process.env.CHATCCC_SEND_IMAGE_TOKEN;
+  const sessionId = args["session-id"] || args.session_id || process.env.CHATCCC_SESSION_ID;
   const path = args.path;
   const caption = args.caption || "";
 
-  if (!url || !token || !path) {
+  if (!url || !sessionId || !path) {
     usage();
     process.exit(1);
   }
 
-  const body = Buffer.from(JSON.stringify({ path, caption }), "utf8");
+  const body = Buffer.from(JSON.stringify({ session_id: sessionId, path, caption }), "utf8");
   const response = await fetch(url, {
     method: "POST",
     headers: {
-      Authorization: `Bearer ${token}`,
       "Content-Type": "application/json; charset=utf-8",
     },
     body,
@@ -49,4 +48,4 @@ async function main() {
 main().catch((err) => {
   console.error(err instanceof Error ? err.message : String(err));
   process.exit(1);
-});
+});

package/im-skills/feishu-skill/skill.md

@@ -7,6 +7,5 @@ Current working directory: {{cwd}}
 
 Use local endpoints instead of calling Feishu Open Platform directly.
 
-- **Get send tokens**: `GET {{session_grants_url}}?sid={{session_id}}` — returns `{ image: {url,token}, file: {url,token} }`
-- **Images** (send & receive): read `{{im_skills_cache_dir}}/feishu-skill/receive-send-image.md`
-- **Files & Videos** (send & download): read `{{im_skills_cache_dir}}/feishu-skill/receive-send-file.md`
+- **Send images**: POST `{{send_image_url}}` with `{"session_id":"{{session_id}}","path":"<absolute path>","caption":"<optional>"}` — read `{{im_skills_cache_dir}}/feishu-skill/receive-send-image.md`
+- **Send files/videos**: POST `{{send_file_url}}` with `{"session_id":"{{session_id}}","path":"<absolute path>","caption":"<optional>"}` — read `{{im_skills_cache_dir}}/feishu-skill/receive-send-file.md`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chatccc",
-  "version": "0.2.45",
+  "version": "0.2.47",
   "description": "Feishu bot bridge for Claude Code",
   "license": "Apache-2.0",
   "type": "module",

package/src/__tests__/agent-image-rpc.test.ts

@@ -3,67 +3,32 @@ import { describe, expect, it } from "vitest";
 import {
   AGENT_SEND_IMAGE_PATH,
   buildAgentImageCapabilityPrompt,
-  createAgentImageGrant,
-  getAgentImageGrantFromAuthorization,
-  revokeAgentImageGrant,
 } from "../agent-image-rpc.ts";
 
-describe("agent image RPC grants", () => {
-  it("creates a per-turn grant and validates bearer authorization", () => {
-    const grant = createAgentImageGrant({
-      chatId: "oc_chat",
-      sessionId: "sid-1",
-      cwd: "F:/repo",
-      port: 18080,
-      nowMs: 1000,
-      ttlMs: 60_000,
-    });
-
-    expect(grant.url).toBe(`http://127.0.0.1:18080${AGENT_SEND_IMAGE_PATH}`);
-    expect(grant.token.length).toBeGreaterThan(20);
-
-    const found = getAgentImageGrantFromAuthorization(
-      `Bearer ${grant.token}`,
-      30_000,
-    );
-    expect(found).toMatchObject({
-      chatId: "oc_chat",
-      sessionId: "sid-1",
-      cwd: "F:/repo",
-    });
-
-    revokeAgentImageGrant(grant.token);
-    expect(getAgentImageGrantFromAuthorization(`Bearer ${grant.token}`, 30_000)).toBeNull();
-  });
-
-  it("rejects missing, malformed, revoked, and expired authorization", () => {
-    const grant = createAgentImageGrant({
-      chatId: "oc_chat",
-      sessionId: "sid-1",
-      cwd: "F:/repo",
-      port: 18080,
-      nowMs: 1000,
-      ttlMs: 10,
-    });
-
-    expect(getAgentImageGrantFromAuthorization("", 1000)).toBeNull();
-    expect(getAgentImageGrantFromAuthorization(grant.token, 1000)).toBeNull();
-    expect(getAgentImageGrantFromAuthorization(`Basic ${grant.token}`, 1000)).toBeNull();
-    expect(getAgentImageGrantFromAuthorization(`Bearer ${grant.token}`, 1011)).toBeNull();
-  });
-
-  it("builds prompt instructions without requiring environment variables", () => {
+describe("agent image RPC", () => {
+  it("builds prompt instructions with session_id", () => {
     const prompt = buildAgentImageCapabilityPrompt({
       url: `http://127.0.0.1:18080${AGENT_SEND_IMAGE_PATH}`,
-      token: "tok_test",
+      sessionId: "sid-test",
     });
 
     expect(prompt).toContain("POST http://127.0.0.1:18080/api/agent/send-image");
-    expect(prompt).toContain("Authorization: Bearer tok_test");
+    expect(prompt).toContain('"session_id":"sid-test"');
     expect(prompt).toContain("Content-Type: application/json; charset=utf-8");
     expect(prompt).toContain("UTF-8 encoded JSON bytes");
-    expect(prompt).toContain("\"path\"");
+    expect(prompt).toContain('"path"');
+    expect(prompt).not.toContain("Authorization: Bearer");
     expect(prompt).not.toContain("CHATCCC_SEND_IMAGE_URL");
     expect(prompt).not.toContain("CHATCCC_SEND_IMAGE_TOKEN");
   });
-});
+
+  it("builds prompt with cwd hint", () => {
+    const prompt = buildAgentImageCapabilityPrompt({
+      url: `http://127.0.0.1:18080${AGENT_SEND_IMAGE_PATH}`,
+      sessionId: "sid-1",
+      cwd: "F:/repo",
+    });
+
+    expect(prompt).toContain("Current working directory: F:/repo");
+  });
+});

package/src/__tests__/session.test.ts

@@ -1,7 +1,22 @@
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
 import { mkdtemp, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { dirname, join } from "node:path";
+
+// mock stream-state 以支持在测试中控制累积长度
+const mockStreamStates = new Map<string, { accumulatedContent: string; finalReply: string }>();
+vi.mock("../stream-state.ts", () => ({
+  readStreamState: async (sid: string) => {
+    const state = mockStreamStates.get(sid);
+    if (!state) return null;
+    return { sessionId: sid, accumulatedContent: state.accumulatedContent, finalReply: state.finalReply, status: "running", chunkCount: 0, turnCount: 0, contextTokens: 0, updatedAt: Date.now(), cwd: "", tool: "claude" };
+  },
+  writeStreamState: async () => {},
+  createEmptyStreamState: (sid: string, cwd: string, tool: string, turnCount: number) => ({
+    sessionId: sid, status: "running" as const, accumulatedContent: "", finalReply: "", chunkCount: 0, turnCount, contextTokens: 0, updatedAt: Date.now(), cwd, tool,
+  }),
+  fixStaleStreamStates: async () => {},
+}));
 import {
   chatSessionMap,
   sessionInfoMap,
@@ -19,6 +34,7 @@ import {
   _setAdapterForToolForTest,
   _clearAdapterCacheForTest,
 } from "../session.ts";
+import { activePrompts } from "../session-chat-binding.ts";
 import type { AccumulatorState } from "../session.ts";
 import type { ToolAdapter, UnifiedBlock, SessionInfo } from "../adapters/adapter-interface.ts";
 
@@ -28,6 +44,18 @@ function mockActiveSession(chatId: string, overrides: Partial<{
   finalText: string;
   stopped: boolean;
 }> = {}) {
+  const info = sessionInfoMap.get(chatId);
+  const sessionId = info?.sessionId ?? "test-session-id";
+  activePrompts.set(sessionId, {
+    controller: new AbortController(),
+    stopped: overrides.stopped ?? false,
+    startTime: Date.now(),
+  });
+  mockStreamStates.set(sessionId, {
+    accumulatedContent: overrides.accumulatedContent ?? "thinking...",
+    finalReply: overrides.finalText ?? "",
+  });
+  // 保留 chatSessionMap 兼容旧测试
   chatSessionMap.set(chatId, {
     gen: 1,
     close: () => {},
@@ -98,6 +126,8 @@ describe("getSessionStatus", () => {
   beforeEach(() => {
     chatSessionMap.clear();
     sessionInfoMap.clear();
+    activePrompts.clear();
+    mockStreamStates.clear();
   });
 
   afterEach(() => {
@@ -258,7 +288,8 @@ describe("getAllSessionsStatus", () => {
     const result = await getAllSessionsStatus();
     expect(result).toHaveLength(2);
     expect(result[0].chatId).toBe("chat1");
-    expect(result[0].active).toBe(true);
+    // running=true in registry doesn't make it active — must be in activePrompts
+    expect(result[0].active).toBe(false);
     expect(result[0].turnCount).toBe(2);
     expect(result[0].chatName).toBe("test-chat-1");
     expect(result[1].chatId).toBe("chat2");
@@ -284,7 +315,7 @@ describe("getAllSessionsStatus", () => {
     expect(result.some((r) => r.chatId === "chat-4")).toBe(false);
   });
 
-  it("marks disk-running sessions as active without checking chatSessionMap", async () => {
+  it("shows session as inactive when not in activePrompts, regardless of registry running field", async () => {
     await recordSessionRegistry({
       chatId: "chat1",
       sessionId: "s1",
@@ -293,6 +324,21 @@ describe("getAllSessionsStatus", () => {
       updatedAt: 1000,
     });
 
+    const result = await getAllSessionsStatus();
+    // After restart, activePrompts is cleared; registry running=true should not show as active
+    expect(result.find(r => r.chatId === "chat1")!.active).toBe(false);
+  });
+
+  it("shows session as active when in activePrompts", async () => {
+    await recordSessionRegistry({
+      chatId: "chat1",
+      sessionId: "s1",
+      tool: "claude",
+      running: false, // registry says false, but activePrompts wins
+      updatedAt: 1000,
+    });
+    mockActiveSession("chat1");
+
     const result = await getAllSessionsStatus();
     expect(result.find(r => r.chatId === "chat1")!.active).toBe(true);
   });

package/src/agent-file-rpc.ts

@@ -1,16 +1,15 @@
-import { randomBytes } from "node:crypto";
 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 } from "./config.ts";
-import { logTrace } from "./trace.ts";
 import { readUtf8JsonBody } from "./agent-rpc-body.ts";
+import { getAdapterForTool } from "./session.ts";
+import { getChatsForSession } from "./session-chat-binding.ts";
 
 export const AGENT_SEND_FILE_PATH = "/api/agent/send-file";
 
-const DEFAULT_GRANT_TTL_MS = 30 * 60 * 1000;
 const MAX_REQUEST_BYTES = 64 * 1024;
 const MAX_FILE_BYTES = 100 * 1024 * 1024;
 const ALLOWED_FILE_EXTS = new Set([
@@ -20,136 +19,139 @@ const ALLOWED_FILE_EXTS = new Set([
   ".txt", ".zip", ".tar", ".gz",
 ]);
 
-export interface AgentFileGrant {
-  token: string;
-  url: string;
-  chatId: string;
-  sessionId: string;
-  cwd: string;
-  expiresAt: number;
-  traceId: string;
-}
-
-const fileGrants = new Map<string, AgentFileGrant>();
-
-function createToken(): string {
-  return randomBytes(24).toString("base64url");
-}
-
-export function createAgentFileGrant(input: {
-  chatId: string;
-  sessionId: string;
-  cwd: string;
-  port: number;
-  traceId?: string;
-  nowMs?: number;
-  ttlMs?: number;
-}): AgentFileGrant {
-  const now = input.nowMs ?? Date.now();
-  const token = createToken();
-  const grant: AgentFileGrant = {
-    token,
-    url: `http://127.0.0.1:${input.port}${AGENT_SEND_FILE_PATH}`,
-    chatId: input.chatId,
-    sessionId: input.sessionId,
-    cwd: input.cwd,
-    expiresAt: now + (input.ttlMs ?? DEFAULT_GRANT_TTL_MS),
-    traceId: input.traceId ?? "",
-  };
-  fileGrants.set(token, grant);
-  if (grant.traceId) logTrace(grant.traceId, "FILE_GRANT_CREATED", { sessionId: grant.sessionId });
-  return grant;
-}
-
-export function revokeAgentFileGrant(token: string): void {
-  const grant = fileGrants.get(token);
-  if (grant?.traceId) logTrace(grant.traceId, "FILE_GRANT_REVOKED", {});
-  fileGrants.delete(token);
-}
-
-function getAgentFileGrantFromAuthorization(authorization: string | undefined, nowMs = Date.now()): AgentFileGrant | null {
-  const match = (authorization ?? "").match(/^Bearer\s+(.+)$/i);
-  if (!match) return null;
-  const grant = fileGrants.get(match[1]);
-  if (!grant) return null;
-  if (grant.expiresAt <= nowMs) { fileGrants.delete(match[1]); return null; }
-  return grant;
-}
-
-export function buildAgentFileCapabilityPrompt(input: { url: string; token: string; cwd?: string }): string {
-  const lines = [
-    "[ChatCCC local capability: send file]",
-    "You can send a file (video, audio, document, etc.) to the current Feishu chat in real time by calling this local endpoint.",
-    "",
-    `POST ${input.url}`,
-    `Authorization: Bearer ${input.token}`,
-    "Content-Type: application/json; charset=utf-8",
-    "",
-    'Body: {"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");
-}
-
 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(grant: AgentFileGrant, rawPath: unknown): Promise<string> {
-  if (typeof rawPath !== "string" || rawPath.trim() === "") throw new Error("path must be a non-empty string");
-  const sessionRoot = resolve(grant.cwd);
-  const filePath = isAbsolute(rawPath) ? resolve(rawPath) : resolve(sessionRoot, rawPath);
+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)"}`);
+  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 ${MAX_FILE_BYTES / 1024 / 1024}MB`);
+  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> {
+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; }
 
-  const grant = getAgentFileGrantFromAuthorization(req.headers.authorization);
-  if (!grant) { jsonReply(res, 401, { ok: false, error: "Invalid or expired file-send token" }); return true; }
-  const tid = grant.traceId;
+  if (req.method !== "POST") {
+    jsonReply(res, 405, { ok: false, error: "Method not allowed" });
+    return true;
+  }
 
-  let payload: { path?: unknown; caption?: unknown };
-  try { payload = await readUtf8JsonBody(req, MAX_REQUEST_BYTES); } catch (err) {
-    if (tid) logTrace(tid, "FILE_REQ", { outcome: "invalid_json", error: (err as Error).message });
-    jsonReply(res, 400, { ok: false, error: (err as Error).message || "Invalid JSON" }); 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 ?? "claude");
+    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(grant, payload.path); } catch (err) {
-    if (tid) logTrace(tid, "FILE_REQ", { outcome: "invalid_path", path: String(payload.path), error: (err as Error).message });
-    jsonReply(res, 400, { ok: false, error: (err as Error).message }); return true;
+  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;
   }
 
   try {
     const token = await getTenantAccessToken();
     const caption = typeof payload.caption === "string" ? payload.caption.trim() : "";
-    await sendFileReply(token, grant.chatId, filePath);
-    if (caption) await sendTextReply(token, grant.chatId, caption);
-    if (tid) logTrace(tid, "FILE_REQ", { outcome: "sent", path: filePath, hasCaption: !!caption });
-    console.log(`[${ts()}] [AGENT-FILE] sent file chat=${grant.chatId} session=${grant.sessionId} path=${filePath}`);
-    jsonReply(res, 200, { ok: true });
+    let sentCount = 0;
+    for (const cid of chatIds) {
+      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}/${chatIds.length} chats, session=${sessionId} path=${filePath}`);
+    jsonReply(res, 200, { ok: true, sentTo: sentCount, total: chatIds.length });
   } catch (err) {
-    if (tid) logTrace(tid, "FILE_REQ", { outcome: "send_failed", path: filePath!, error: (err as Error).message });
     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");
+}