chatccc 0.2.267 → 0.2.269

package/dist/src/safe-maintenance.js

@@ -0,0 +1,271 @@
+import { randomUUID } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { USER_DATA_DIR } from "./config.js";
+export const SAFE_MAINTENANCE_FILE = join(USER_DATA_DIR, "state", "safe-maintenance.json");
+export const SAFE_MAINTENANCE_STABLE_IDLE_MS = 1_000;
+const EMPTY_SNAPSHOT = {
+    activeSessionIds: [],
+    queuedSessionIds: [],
+    activeEngineIds: [],
+    activeWorkLabels: [],
+};
+export class SafeMaintenanceCoordinator {
+    filePath;
+    now;
+    idFactory;
+    stableIdleMs;
+    pollMs;
+    autoPoll;
+    trackedWork = new Map();
+    runtime = null;
+    job;
+    snapshot = EMPTY_SNAPSHOT;
+    stableSince = null;
+    timer = null;
+    tickRunning = false;
+    constructor(options = {}) {
+        this.filePath = options.filePath ?? SAFE_MAINTENANCE_FILE;
+        this.now = options.now ?? (() => new Date());
+        this.idFactory = options.idFactory ?? randomUUID;
+        this.stableIdleMs = options.stableIdleMs ?? SAFE_MAINTENANCE_STABLE_IDLE_MS;
+        this.pollMs = options.pollMs ?? 500;
+        this.autoPoll = options.autoPoll ?? true;
+        this.job = readJob(this.filePath);
+    }
+    configure(runtime) {
+        this.runtime = runtime;
+    }
+    isAdmissionClosed() {
+        return this.job?.phase === "draining" || this.job?.phase === "executing";
+    }
+    beginTrackedWork(label) {
+        const id = this.idFactory();
+        this.trackedWork.set(id, label);
+        let released = false;
+        return () => {
+            if (released)
+                return;
+            released = true;
+            this.trackedWork.delete(id);
+        };
+    }
+    async schedule(kind, requester) {
+        const now = this.now().toISOString();
+        if (this.job?.phase === "executing")
+            return structuredClone(this.job);
+        const previous = this.job;
+        if (this.job?.phase === "draining") {
+            const requesters = addRequester(this.job.requesters, requester);
+            this.job = {
+                ...this.job,
+                kind: this.job.kind === "update" || kind === "update" ? "update" : "restart",
+                requesters,
+                updatedAt: now,
+            };
+        }
+        else {
+            this.job = {
+                schemaVersion: 1,
+                jobId: this.idFactory(),
+                kind,
+                phase: "draining",
+                requestedAt: now,
+                updatedAt: now,
+                requesters: [requester],
+            };
+        }
+        this.stableSince = null;
+        try {
+            writeJob(this.filePath, this.job);
+        }
+        catch (error) {
+            this.job = previous;
+            throw error;
+        }
+        this.startPolling();
+        return structuredClone(this.job);
+    }
+    async cancel(notify = true) {
+        if (this.job?.phase !== "draining")
+            return false;
+        const requesters = this.job.requesters;
+        removeJob(this.filePath);
+        this.job = null;
+        this.snapshot = EMPTY_SNAPSHOT;
+        this.stableSince = null;
+        this.stopPolling();
+        if (notify)
+            await this.notifyAll(requesters, "已取消安全维护预约，ChatCCC 恢复接受新任务。");
+        return true;
+    }
+    async status() {
+        if (this.runtime && this.isAdmissionClosed())
+            this.snapshot = await this.collectSnapshot();
+        return {
+            job: this.job ? structuredClone(this.job) : null,
+            snapshot: structuredClone(this.snapshot),
+            waitingCount: snapshotCount(this.snapshot),
+        };
+    }
+    async tick() {
+        if (this.tickRunning || this.job?.phase !== "draining" || !this.runtime)
+            return;
+        this.tickRunning = true;
+        try {
+            this.snapshot = await this.collectSnapshot();
+            if (snapshotCount(this.snapshot) > 0) {
+                this.stableSince = null;
+                return;
+            }
+            const nowMs = this.now().getTime();
+            if (this.stableSince === null) {
+                this.stableSince = nowMs;
+                return;
+            }
+            if (nowMs - this.stableSince < this.stableIdleMs)
+                return;
+            await this.executeCurrentJob();
+        }
+        finally {
+            this.tickRunning = false;
+        }
+    }
+    async recoverAfterStartup(internalRestart) {
+        if (!this.job || !this.runtime)
+            return;
+        if (this.job.phase === "draining") {
+            this.startPolling();
+            await this.notifyAll(this.job.requesters, "ChatCCC 已恢复未完成的安全维护预约，继续等待现有任务结束。");
+            return;
+        }
+        if (this.job.phase !== "executing")
+            return;
+        if (internalRestart) {
+            const completed = { ...this.job, phase: "completed", updatedAt: this.now().toISOString() };
+            writeJob(this.filePath, completed);
+            this.job = completed;
+            await this.notifyAll(this.job.requesters, this.job.kind === "update" ? "ChatCCC 已安全更新并重新启动。" : "ChatCCC 已安全重新启动。");
+            return;
+        }
+        const message = "安全维护执行期间进程意外退出；为避免重启循环，未自动重试。";
+        const failed = {
+            ...this.job,
+            phase: "failed",
+            updatedAt: this.now().toISOString(),
+            lastError: message,
+        };
+        writeJob(this.filePath, failed);
+        this.job = failed;
+        await this.notifyAll(this.job.requesters, message);
+    }
+    async collectSnapshot() {
+        const external = await this.runtime.getSnapshot();
+        return {
+            activeSessionIds: [...external.activeSessionIds],
+            queuedSessionIds: [...external.queuedSessionIds],
+            activeEngineIds: [...external.activeEngineIds],
+            activeWorkLabels: [...external.activeWorkLabels, ...this.trackedWork.values()],
+        };
+    }
+    async executeCurrentJob() {
+        if (!this.job || !this.runtime)
+            return;
+        const executing = { ...this.job, phase: "executing", updatedAt: this.now().toISOString() };
+        writeJob(this.filePath, executing);
+        this.job = executing;
+        this.stopPolling();
+        const label = this.job.kind === "update" ? "更新并重启" : "重启";
+        await this.notifyAll(this.job.requesters, `现有任务已全部完成，开始安全${label}。`);
+        const started = await this.runtime.execute(this.job.kind).catch(async (error) => {
+            await this.markFailed(error instanceof Error ? error.message : String(error));
+            return false;
+        });
+        if (!started && this.job?.phase === "executing") {
+            await this.markFailed(`安全${label}未能启动，当前进程将继续提供服务。`);
+        }
+    }
+    async markFailed(message) {
+        if (!this.job)
+            return;
+        const failed = {
+            ...this.job,
+            phase: "failed",
+            updatedAt: this.now().toISOString(),
+            lastError: message,
+        };
+        writeJob(this.filePath, failed);
+        this.job = failed;
+        await this.notifyAll(this.job.requesters, message);
+    }
+    startPolling() {
+        if (!this.autoPoll || this.timer || this.job?.phase !== "draining")
+            return;
+        this.timer = setInterval(() => { void this.tick(); }, this.pollMs);
+        this.timer.unref?.();
+    }
+    stopPolling() {
+        if (!this.timer)
+            return;
+        clearInterval(this.timer);
+        this.timer = null;
+    }
+    async notifyAll(requesters, message) {
+        if (!this.runtime)
+            return;
+        await Promise.all(requesters.map((requester) => this.runtime.notify(requester, message).catch(() => { })));
+    }
+}
+function snapshotCount(snapshot) {
+    return snapshot.activeSessionIds.length
+        + snapshot.queuedSessionIds.length
+        + snapshot.activeEngineIds.length
+        + snapshot.activeWorkLabels.length;
+}
+function addRequester(requesters, requester) {
+    if (requesters.some((item) => item.platform === requester.platform && item.chatId === requester.chatId))
+        return requesters;
+    return [...requesters, requester];
+}
+function readJob(filePath) {
+    if (!existsSync(filePath))
+        return null;
+    try {
+        const value = JSON.parse(readFileSync(filePath, "utf8"));
+        if (value.schemaVersion !== 1 || !value.jobId || !Array.isArray(value.requesters))
+            return null;
+        if (!["restart", "update"].includes(value.kind) || !["draining", "executing", "completed", "failed"].includes(value.phase))
+            return null;
+        return value;
+    }
+    catch {
+        return null;
+    }
+}
+function writeJob(filePath, job) {
+    mkdirSync(dirname(filePath), { recursive: true });
+    const temporary = `${filePath}.${process.pid}.${randomUUID()}.tmp`;
+    try {
+        writeFileSync(temporary, `${JSON.stringify(job, null, 2)}\n`, "utf8");
+        renameSync(temporary, filePath);
+    }
+    finally {
+        rmSync(temporary, { force: true });
+    }
+}
+function removeJob(filePath) {
+    rmSync(filePath, { force: true });
+}
+export let safeMaintenanceCoordinator = new SafeMaintenanceCoordinator();
+export function _setSafeMaintenanceCoordinatorForTest(coordinator) {
+    safeMaintenanceCoordinator = coordinator;
+}
+export function _resetSafeMaintenanceCoordinatorForTest() {
+    safeMaintenanceCoordinator = new SafeMaintenanceCoordinator();
+}
+export function isSafeMaintenanceAdmissionClosed() {
+    return safeMaintenanceCoordinator.isAdmissionClosed();
+}
+export function beginSafeMaintenanceTrackedWork(label) {
+    return safeMaintenanceCoordinator.beginTrackedWork(label);
+}

package/dist/src/session-chat-binding.js

@@ -133,6 +133,18 @@ export function setUnifiedDisplayLoopHandle(h) {
     unifiedDisplayLoopHandle = h;
 }
 export const queuedMessages = new Map();
+/** Includes prompt execution, finalization, auto-recovery reservations, and accepted queues. */
+export function getSessionDrainSnapshot() {
+    const active = new Set([
+        ...activePrompts.keys(),
+        ...finalizingSessions,
+        ...autoRecoveryReservations,
+    ]);
+    return {
+        activeSessionIds: [...active].sort(),
+        queuedSessionIds: [...queuedMessages.keys()].sort(),
+    };
+}
 export function enqueueMessage(sessionId, msg) {
     if (queuedMessages.has(sessionId))
         return false;

package/dist/src/session.js

@@ -6,6 +6,7 @@ import { progressView } from "./progress/view.js";
 import { createAgentActivityTracker, formatAgentActivityTitle, updateAgentActivity, } from "./agent-activity.js";
 import { simplifyToolUse, simplifyToolResult } from "./simplify.js";
 import { logTrace } from "./trace.js";
+import { appendExecutionTranscriptBlock, } from "./execution-transcript.js";
 import { createClaudeAdapter } from "./adapters/claude-adapter.js";
 import { createCursorAdapter } from "./adapters/cursor-adapter.js";
 import { createCodexAdapter } from "./adapters/codex-adapter.js";
@@ -698,6 +699,11 @@ export function pickFinalReply(state) {
     return state.finalCompleteText || state.finalText;
 }
 export function accumulateBlockContent(block, state, toolCallMap) {
+    if (state.transcript !== undefined || (block.type !== "agent_progress" && block.type !== "text_reset")) {
+        const transcriptState = { transcript: state.transcript ?? [] };
+        appendExecutionTranscriptBlock(block, transcriptState);
+        state.transcript = transcriptState.transcript;
+    }
     switch (block.type) {
         case "thinking":
             state.chunkCount++;
@@ -907,8 +913,10 @@ export async function initClaudeSession(tool, overrideCwd, chatId) {
     await addRecentDir(cwd);
     return { sessionId, cwd };
 }
-export async function resumeAndPrompt(sessionId, userText, platform, chatId, msgTimestamp, tool, traceId) {
-    return runAgentSession(sessionId, userText, platform, chatId, msgTimestamp, tool, traceId);
+export async function resumeAndPrompt(sessionId, userText, platform, chatId, msgTimestamp, tool, traceId, initiatorOpenId) {
+    return runAgentSession(sessionId, userText, platform, chatId, msgTimestamp, tool, traceId, {
+        initiatorOpenId,
+    });
 }
 export async function runAgentSession(sessionId, userText, platform, _chatId, msgTimestamp, tool, traceId, options = {}) {
     const tid = traceId ?? "";
@@ -984,8 +992,10 @@ export async function runAgentSession(sessionId, userText, platform, _chatId, ms
         const skillVariables = {
             cwd,
             session_id: sessionId,
+            open_id: options.initiatorOpenId,
             im_skills_cache_dir: imSkillsCacheDir,
             delegate_task_url: `http://127.0.0.1:${CHATCCC_PORT}/api/agent/delegate-task`,
+            set_cwd_url: `http://127.0.0.1:${CHATCCC_PORT}/api/agent/set-cwd`,
             send_image_url: `http://127.0.0.1:${CHATCCC_PORT}/api/agent/send-image`,
             send_file_url: `http://127.0.0.1:${CHATCCC_PORT}/api/agent/send-file`,
             send_image_script: join(feishuSkillDir, "send-image.mjs"),
@@ -1145,6 +1155,7 @@ export async function runAgentSession(sessionId, userText, platform, _chatId, ms
     refreshBusySessionAvatar(sessionId, tool, platform).catch(() => { });
     const state = {
         accumulatedContent: "",
+        transcript: [],
         finalText: "",
         finalCompleteText: "",
         chunkCount: 0,
@@ -1196,6 +1207,7 @@ export async function runAgentSession(sessionId, userText, platform, _chatId, ms
                 status: "auto_ended",
                 accumulatedContent: state.accumulatedContent,
                 finalReply: pickFinalReply(state).trim(),
+                transcript: state.transcript,
                 activity: activityTracker.activity,
                 chunkCount: state.chunkCount,
                 turnCount: nextTurnCount,
@@ -1308,6 +1320,7 @@ export async function runAgentSession(sessionId, userText, platform, _chatId, ms
                     status: "running",
                     accumulatedContent: state.accumulatedContent,
                     finalReply: pickFinalReply(state),
+                    transcript: state.transcript,
                     activity: activityTracker.activity,
                     chunkCount: state.chunkCount,
                     turnCount: nextTurnCount,
@@ -1406,6 +1419,7 @@ export async function runAgentSession(sessionId, userText, platform, _chatId, ms
                 status: finalStatus,
                 accumulatedContent: state.accumulatedContent,
                 finalReply: finalReplyToWrite,
+                transcript: state.transcript,
                 activity: activityTracker.activity,
                 chunkCount: state.chunkCount,
                 turnCount: nextTurnCount,

package/dist/src/stream-state.js

@@ -100,6 +100,7 @@ export function createEmptyStreamState(sessionId, cwd, tool, turnCount) {
         status: "running",
         accumulatedContent: "",
         finalReply: "",
+        transcript: [],
         activity: createAgentActivityTracker(now).activity,
         chunkCount: 0,
         turnCount,

package/dist/src/web-ui.js

@@ -17,6 +17,7 @@ import { AGENT_TEAM_PAGE_HTML } from "./agent-team/web/agent-team-page.js";
 export { AGENT_TEAM_PAGE_HTML } from "./agent-team/web/agent-team-page.js";
 import { buildWebUiUrl, createInternalRestartEnv, openWebUiInDefaultBrowser, } from "./startup-lifecycle.js";
 import { engineManager } from "./engines/engine-specs.js";
+import { isSafeMaintenanceAdmissionClosed } from "./safe-maintenance.js";
 const PROJECT_ROOT = CHATCCC_PACKAGE_ROOT;
 const USER_DATA_DIR = join(homedir(), ".chatccc");
 const CONFIG_FILE = join(USER_DATA_DIR, "config.json");
@@ -656,6 +657,10 @@ async function handleEngineStatus(engineId, res) {
     }
 }
 async function handleEngineInstall(engineId, res) {
+    if (isSafeMaintenanceAdmissionClosed()) {
+        jsonReply(res, 409, { ok: false, error: "ChatCCC 正在等待安全维护，暂不接受新的依赖安装任务。" });
+        return;
+    }
     try {
         jsonReply(res, 202, { ok: true, job: await engineManager.startInstall(engineId) });
     }

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

@@ -1,12 +1,26 @@
 ---
 name: feishu-skill
-description: Feishu IM local skills for sending and receiving images, files, and videos.
+description: Feishu IM local skills for sending images, files, videos, and for creating new sessions or switching working directories.
 ---
 
 Current working directory: {{cwd}}
+Your session id: {{session_id}}
+Your Feishu open_id: {{open_id}}
 
 Use local endpoints instead of calling Feishu Open Platform directly.
 
-- **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`
-- **Delegate a task to a new agent conversation**: POST `{{delegate_task_url}}` with `{"tool":"codex|claude|cursor","cwd":"<absolute working directory>","open_id":"<Feishu user open_id>","prompt":"<first task>"}`. Use `open_ids` for multiple users. This uses the normal ChatCCC prompt flow, so project prompt injection and IM skills still apply.
+- **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`
+- **Create a new session (新建会话)**: POST `{{delegate_task_url}}` with `{"tool":"claude|cursor|codex|ccc|dsh","cwd":"<absolute path>","open_id":"{{open_id}}","prompt":"<optional first task>"}`. This creates a new Feishu group and session, and only adds you (the requester). `tool` and `prompt` are optional; omit `prompt` to just create the session without a first task.
+- **Set default working directory (cd / 切换目录)**: POST `{{set_cwd_url}}` with `{"session_id":"{{session_id}}","dir":"<absolute path>"}`. This sets the default directory for future new sessions only; it does not change the current session.
+
+How to map user requests to these endpoints:
+
+- "新建会话 / 开个新会话 / 换个新会话" → create a new session (no prompt). Use `cwd` = your current working directory ({{cwd}}) unless the user names a directory.
+- "在 <目录> 新建会话（做 <任务>）" → create a new session with `cwd` = that directory, and set `prompt` to the task if one was given.
+- "cd 到 <目录> / 切换到 <目录> / 去 <目录> 干活" → judge intent:
+  - if the user wants to start working there now (a fresh conversation in that directory) → create a new session with `cwd` = that directory.
+  - if the user only wants to change the default directory for future sessions → call set-cwd.
+  - when ambiguous, prefer creating a new session (the more common intent for "切换到").
+- Directory names may be fuzzy or relative; resolve them to an absolute local path (using your file tools) before calling either endpoint.
+- `open_id` must always be passed as exactly {{open_id}}; do not invent it.

package/package.json

@@ -1,76 +1,76 @@
-{
-  "name": "chatccc",
-  "version": "0.2.267",
-  "description": "Feishu bot bridge for Claude Code",
-  "license": "Apache-2.0",
-  "type": "module",
-  "main": "./dist/src/index.js",
-  "bin": {
-    "chatccc": "bin/chatccc.mjs",
-    "cccagent": "bin/cccagent.mjs"
-  },
-  "files": [
-    "dist/",
-    "deepccc-agent/os-prompts/",
-    "bin/",
-    "scripts/postinstall-sharp-check.mjs",
-    "demo/ilink_echo_probe.ts",
-    "agent-prompts/",
-    "im-skills/",
-    ".agents/skills/create-chatccc-feishu-app/",
-    ".claude/skills/create-chatccc-feishu-app/",
-    ".cursor/skills/create-chatccc-feishu-app/",
-    "images/img_readme_*.jpg",
-    "images/img_readme_*.png",
-    "images/avatars/status_*.png",
-    "images/avatars/badges/",
-    "images/avatars/combinations/",
-    "package.json",
-    "README.md",
-    "config.sample.json"
-  ],
-  "scripts": {
-    "build": "node scripts/build.mjs",
-    "prepack": "npm run build",
-    "dev": "tsx src/index.ts",
-    "chatccc": "tsx src/index.ts",
-    "start": "tsx src/index.ts",
-    "demo:bot-test": "tsx demo/bot_test.ts",
-    "demo:bot-test:local": "tsx demo/bot_test.ts --local",
-    "demo:create-group": "tsx src/index.ts",
-    "demo:create-group:local": "tsx src/index.ts --local",
-    "demo:permission-check": "tsx demo/permission_check.ts",
-    "demo:claude-hi": "tsx demo/claude_say_hi.ts",
-    "demo:codex-hi": "tsx demo/codex_say_hi.ts",
-    "demo:codex-app-server-approval": "tsx demo/codex-app-server-approval/approval_demo.ts",
-    "demo:ilink-echo": "tsx demo/ilink_echo_probe.ts",
-    "claude-proxy": "tsx src/litellm-proxy.ts",
-    "test": "vitest run",
-    "test:deepccc": "vitest run --root deepccc-agent",
-    "test:watch": "vitest",
-    "postinstall": "node scripts/postinstall-sharp-check.mjs"
-  },
-  "dependencies": {
-    "@ai-sdk/anthropic": "^3.0.105",
-    "@ai-sdk/openai-compatible": "^2.0.47",
-    "@larksuiteoapi/node-sdk": "^1.59.0",
-    "@openilink/openilink-sdk-node": "^0.6.0",
-    "@vscode/ripgrep": "^1.18.0",
-    "ai": "^6.0.184",
-    "nodemailer": "^8.0.7",
-    "qrcode-terminal": "^0.12.0",
-    "sharp": "^0.34.5",
-    "ws": "^8.18.0"
-  },
-  "devDependencies": {
-    "@types/node": "^20.0.0",
-    "@types/qrcode-terminal": "^0.12.2",
-    "@types/ws": "^8.18.1",
-    "tsx": "^4.0.0",
-    "typescript": "^5.0.0",
-    "vitest": "^3.2.4"
-  },
-  "engines": {
-    "node": ">=20"
-  }
-}
+{
+  "name": "chatccc",
+  "version": "0.2.269",
+  "description": "Feishu bot bridge for Claude Code",
+  "license": "Apache-2.0",
+  "type": "module",
+  "main": "./dist/src/index.js",
+  "bin": {
+    "chatccc": "bin/chatccc.mjs",
+    "cccagent": "bin/cccagent.mjs"
+  },
+  "files": [
+    "dist/",
+    "deepccc-agent/os-prompts/",
+    "bin/",
+    "scripts/postinstall-sharp-check.mjs",
+    "demo/ilink_echo_probe.ts",
+    "agent-prompts/",
+    "im-skills/",
+    ".agents/skills/create-chatccc-feishu-app/",
+    ".claude/skills/create-chatccc-feishu-app/",
+    ".cursor/skills/create-chatccc-feishu-app/",
+    "images/img_readme_*.jpg",
+    "images/img_readme_*.png",
+    "images/avatars/status_*.png",
+    "images/avatars/badges/",
+    "images/avatars/combinations/",
+    "package.json",
+    "README.md",
+    "config.sample.json"
+  ],
+  "scripts": {
+    "build": "node scripts/build.mjs",
+    "prepack": "npm run build",
+    "dev": "tsx src/index.ts",
+    "chatccc": "tsx src/index.ts",
+    "start": "tsx src/index.ts",
+    "demo:bot-test": "tsx demo/bot_test.ts",
+    "demo:bot-test:local": "tsx demo/bot_test.ts --local",
+    "demo:create-group": "tsx src/index.ts",
+    "demo:create-group:local": "tsx src/index.ts --local",
+    "demo:permission-check": "tsx demo/permission_check.ts",
+    "demo:claude-hi": "tsx demo/claude_say_hi.ts",
+    "demo:codex-hi": "tsx demo/codex_say_hi.ts",
+    "demo:codex-app-server-approval": "tsx demo/codex-app-server-approval/approval_demo.ts",
+    "demo:ilink-echo": "tsx demo/ilink_echo_probe.ts",
+    "claude-proxy": "tsx src/litellm-proxy.ts",
+    "test": "vitest run",
+    "test:deepccc": "vitest run --root deepccc-agent",
+    "test:watch": "vitest",
+    "postinstall": "node scripts/postinstall-sharp-check.mjs"
+  },
+  "dependencies": {
+    "@ai-sdk/anthropic": "^3.0.105",
+    "@ai-sdk/openai-compatible": "^2.0.47",
+    "@larksuiteoapi/node-sdk": "^1.59.0",
+    "@openilink/openilink-sdk-node": "^0.6.0",
+    "@vscode/ripgrep": "^1.18.0",
+    "ai": "^6.0.184",
+    "nodemailer": "^8.0.7",
+    "qrcode-terminal": "^0.12.0",
+    "sharp": "^0.34.5",
+    "ws": "^8.18.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "@types/qrcode-terminal": "^0.12.2",
+    "@types/ws": "^8.18.1",
+    "tsx": "^4.0.0",
+    "typescript": "^5.0.0",
+    "vitest": "^3.2.4"
+  },
+  "engines": {
+    "node": ">=20"
+  }
+}