@wu529778790/open-im 1.9.4-beta.1 → 1.9.4-beta.10

package/dist/access/access-control.js

@@ -8,7 +8,7 @@ export class AccessControl {
     }
     isAllowed(userId) {
         if (this.allowedUserIds.size === 0) {
-            log.warn(`Allowing user ${userId} — no whitelist configured. Set allowedUserIds to restrict access.`);
+            log.warn(`SECURITY: Allowing user ${userId} -- no whitelist configured. Set allowedUserIds in config or OPEN_IM_ALLOWED_USER_IDS env var to restrict access.`);
             return true;
         }
         const allowed = this.allowedUserIds.has(userId);

package/dist/adapters/claude-sdk-adapter.js

@@ -9,8 +9,34 @@
  * 认证：ANTHROPIC_API_KEY 或 CLAUDE_CODE_OAUTH_TOKEN
  */
 import { unstable_v2_createSession, unstable_v2_resumeSession } from '@anthropic-ai/claude-agent-sdk';
+import { existsSync, readFileSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
 import { createLogger } from '../logger.js';
 const log = createLogger('ClaudeSDK');
+function loadUserPluginSettings() {
+    try {
+        const settingsPath = join(homedir(), '.claude', 'settings.json');
+        if (!existsSync(settingsPath))
+            return null;
+        const content = readFileSync(settingsPath, 'utf-8');
+        const settings = JSON.parse(content);
+        const result = {};
+        if (settings.enabledPlugins)
+            result.enabledPlugins = settings.enabledPlugins;
+        if (settings.extraKnownMarketplaces)
+            result.extraKnownMarketplaces = settings.extraKnownMarketplaces;
+        if (Object.keys(result).length === 0)
+            return null;
+        log.info(`Loaded user plugin settings: plugins=[${Object.keys(result.enabledPlugins ?? {}).join(', ')}]`);
+        return result;
+    }
+    catch (err) {
+        log.warn('Failed to read ~/.claude/settings.json for plugin config:', err);
+        return null;
+    }
+}
+const userPluginSettings = loadUserPluginSettings();
 // 存储所有活跃的 SDKSession 对象，key 为 sessionId
 // 使用 Map 而不是 Set，因为我们需要通过 sessionId 获取 session
 const activeSessions = new Map();
@@ -22,6 +48,8 @@ const sessionLastUsed = new Map();
 const runningSessions = new Set();
 const SESSION_IDLE_TTL_MS = 30 * 60 * 1000; // 30 分钟未使用则清理
 const CLEANUP_INTERVAL_MS = 5 * 60 * 1000; // 每 5 分钟检查一次
+const MAX_ACTIVE_SESSIONS = 100;
+let sessionSeq = 0;
 const cleanupInterval = setInterval(() => {
     const now = Date.now();
     for (const [id, lastUsed] of sessionLastUsed) {
@@ -42,33 +70,17 @@ const cleanupInterval = setInterval(() => {
     }
 }, CLEANUP_INTERVAL_MS);
 cleanupInterval.unref(); // 不阻止进程退出
-// Lazy cleanup: check idle sessions periodically during getOrCreateSession calls
-let lazyCleanupCounter = 0;
-const LAZY_CLEANUP_INTERVAL = 10;
-let sessionSeq = 0;
-function lazyCleanupIdleSessions() {
-    lazyCleanupCounter++;
-    if (lazyCleanupCounter % LAZY_CLEANUP_INTERVAL !== 0)
-        return;
-    const now = Date.now();
-    for (const [id, lastUsed] of sessionLastUsed) {
-        if (runningSessions.has(id))
-            continue; // 跳过正在运行任务的 session
-        if (now - lastUsed > SESSION_IDLE_TTL_MS) {
-            const s = activeSessions.get(id);
-            if (s) {
-                try {
-                    s.close();
-                }
-                catch { /* ignore */ }
-                activeSessions.delete(id);
-            }
-            sessionLastUsed.delete(id);
-            log.info(`Lazy cleanup: idle session ${id} (unused ${Math.round((now - lastUsed) / 60000)}min)`);
-        }
-    }
-}
-// Mutex to serialize process.chdir() calls across concurrent users
+/**
+ * Serializes process.chdir() calls across concurrent users.
+ *
+ * process.chdir() is a process-wide global side effect — only one chdir can
+ * be active at a time. The SDK's createSession/resumeSession do not accept a
+ * `cwd` parameter, so we must chdir before calling them. This mutex ensures
+ * concurrent requests don't race on the working directory.
+ *
+ * **Limitation:** If the SDK ever supports a `cwd` option, this mutex should
+ * be removed entirely.
+ */
 let chdirMutex = Promise.resolve();
 function withChdirMutex(fn) {
     const previous = chdirMutex;
@@ -108,8 +120,10 @@ function isSessionCorruptionError(msg) {
  * @returns SDKSession 对象和实际的 sessionId
  */
 async function getOrCreateSession(sessionId, workDir, model, permissionMode) {
-    lazyCleanupIdleSessions();
     const resolvedModel = model?.trim() || 'claude-opus-4-5';
+    if (activeSessions.size >= MAX_ACTIVE_SESSIONS) {
+        throw new Error(`Session pool is full (${MAX_ACTIVE_SESSIONS}). Cannot create new session.`);
+    }
     const sessionOptions = {
         model: resolvedModel,
         permissionMode,
@@ -156,7 +170,7 @@ async function getOrCreateSession(sessionId, workDir, model, permissionMode) {
             activeSessions.set(tempId, session);
             sessionLastUsed.set(tempId, Date.now());
             log.info(`Created new session (tempId: ${tempId})`);
-            return { session, sessionId: tempId };
+            return { session, sessionId: tempId, wasReused: false };
         }
         finally {
             if (workDir && workDir !== originalCwd) {
@@ -260,7 +274,13 @@ export class ClaudeSDKAdapter {
                         }
                         // 获取实际的 sessionId（从 init 消息中）
                         if (isSystemInit(msg)) {
-                            const newSessionId = msg.session_id;
+                            const initMsg = msg;
+                            // 记录 session 加载的插件和技能
+                            const pluginNames = initMsg.plugins?.map(p => p.name).join(', ') ?? 'none';
+                            const skillCount = initMsg.skills?.length ?? 0;
+                            const toolCount = initMsg.tools?.length ?? 0;
+                            log.info(`[V2] Init: plugins=[${pluginNames}], skills=${skillCount}, tools=${toolCount}`);
+                            const newSessionId = initMsg.session_id;
                             if (newSessionId && newSessionId !== actualSessionId) {
                                 // 更新 sessionId 映射
                                 // 清理 pending 临时 ID（actualSessionId 尚未赋值时用 pendingTempId）

package/dist/adapters/claude-sdk-adapter.test.js

@@ -0,0 +1,50 @@
+import { describe, expect, it, vi, beforeEach, afterEach } from 'vitest';
+// Mock the logger before importing the adapter under test
+vi.mock('../logger.js', () => ({
+    createLogger: () => ({
+        info: vi.fn(),
+        warn: vi.fn(),
+        error: vi.fn(),
+        debug: vi.fn(),
+    }),
+}));
+// Mock the Claude Agent SDK
+vi.mock('@anthropic-ai/claude-agent-sdk', () => ({
+    unstable_v2_createSession: vi.fn(),
+    unstable_v2_resumeSession: vi.fn(),
+}));
+// Import after mocks are set up
+import { ClaudeSDKAdapter } from './claude-sdk-adapter.js';
+describe('ClaudeSDKAdapter', () => {
+    let adapter;
+    beforeEach(() => {
+        adapter = new ClaudeSDKAdapter();
+    });
+    afterEach(() => {
+        // Clean up any active sessions/timers created during tests
+        ClaudeSDKAdapter.destroy();
+    });
+    it('implements the ToolAdapter interface', () => {
+        expect(adapter).toBeDefined();
+        expect(typeof adapter.toolId).toBe('string');
+        expect(typeof adapter.run).toBe('function');
+    });
+    it('has toolId set to claude-sdk', () => {
+        expect(adapter.toolId).toBe('claude-sdk');
+    });
+    it('has a run method that returns a RunHandle', () => {
+        const callbacks = {
+            onText: vi.fn(),
+            onComplete: vi.fn(),
+            onError: vi.fn(),
+        };
+        const handle = adapter.run('test prompt', undefined, '/tmp', callbacks);
+        expect(handle).toBeDefined();
+        expect(typeof handle.abort).toBe('function');
+        // Abort to clean up the background promise
+        handle.abort();
+    });
+    it('stop() (static destroy) does not throw', () => {
+        expect(() => ClaudeSDKAdapter.destroy()).not.toThrow();
+    });
+});

package/dist/config/credentials.d.ts

@@ -0,0 +1,27 @@
+import type { FileConfig } from './types.js';
+/**
+ * Resolves a single credential value using the standard priority chain:
+ * environment variable → platform file config → legacy file config.
+ */
+export declare function resolveCredential(envKey: string, fileValue?: string, legacyFileValue?: string): string | undefined;
+/**
+ * Generic per-platform credential resolution.
+ * Returns all resolved credentials and whether the platform should be enabled.
+ */
+export interface ResolvedPlatform {
+    enabled: boolean;
+    credentials: Record<string, string | undefined>;
+}
+export declare function resolvePlatformCredentials(envKeys: Record<string, string>, fileValues: Record<string, string | undefined>, legacyValues: Record<string, string | undefined>, requiredKeys: string[], enabledFlag?: boolean): ResolvedPlatform;
+/**
+ * Extract WorkBuddy credentials, with legacy platforms.wechat migration support.
+ */
+export declare function resolveWorkBuddyFileConfig(fileConfig: FileConfig): NonNullable<FileConfig['platforms']>['workbuddy'] | undefined;
+/**
+ * Check if a CLI tool is available at the given path or on PATH.
+ */
+export declare function checkCliAvailable(cliPath: string, toolName: string): void;
+/**
+ * Resolve Windows-specific CLI path for npm global installs.
+ */
+export declare function resolveWindowsCliPath(cliName: string, configuredPath: string): string;

package/dist/config/credentials.js

@@ -0,0 +1,85 @@
+import { accessSync, constants } from 'node:fs';
+import { execFileSync } from 'node:child_process';
+import { join, isAbsolute } from 'node:path';
+/**
+ * Resolves a single credential value using the standard priority chain:
+ * environment variable → platform file config → legacy file config.
+ */
+export function resolveCredential(envKey, fileValue, legacyFileValue) {
+    return process.env[envKey] ?? fileValue ?? legacyFileValue;
+}
+export function resolvePlatformCredentials(envKeys, fileValues, legacyValues, requiredKeys, enabledFlag) {
+    const credentials = {};
+    for (const [name, envKey] of Object.entries(envKeys)) {
+        credentials[name] = resolveCredential(envKey, fileValues[name], legacyValues[name]);
+    }
+    const hasRequired = requiredKeys.every((key) => credentials[key] !== undefined && credentials[key] !== '');
+    return {
+        enabled: hasRequired && enabledFlag !== false,
+        credentials,
+    };
+}
+/**
+ * Extract WorkBuddy credentials, with legacy platforms.wechat migration support.
+ */
+export function resolveWorkBuddyFileConfig(fileConfig) {
+    const direct = fileConfig.platforms?.workbuddy;
+    if (direct)
+        return direct;
+    const legacyWechat = fileConfig.platforms?.wechat;
+    if (legacyWechat?.workbuddyAccessToken && legacyWechat?.workbuddyRefreshToken) {
+        return {
+            accessToken: legacyWechat.workbuddyAccessToken,
+            refreshToken: legacyWechat.workbuddyRefreshToken,
+            userId: legacyWechat.userId,
+            baseUrl: legacyWechat.workbuddyBaseUrl,
+        };
+    }
+    return undefined;
+}
+/**
+ * Check if a CLI tool is available at the given path or on PATH.
+ */
+export function checkCliAvailable(cliPath, toolName) {
+    if (isAbsolute(cliPath) || cliPath.includes('/') || cliPath.includes('\\')) {
+        try {
+            accessSync(cliPath, constants.F_OK);
+        }
+        catch {
+            throw new Error(`${toolName} CLI not found at: ${cliPath}`);
+        }
+    }
+    else {
+        const checkCommand = process.platform === 'win32' ? 'where' : 'which';
+        try {
+            execFileSync(checkCommand, [cliPath], {
+                stdio: 'pipe',
+                windowsHide: process.platform === 'win32',
+            });
+        }
+        catch {
+            throw new Error(`${toolName} CLI not found on PATH: ${cliPath}`);
+        }
+    }
+}
+/**
+ * Resolve Windows-specific CLI path for npm global installs.
+ */
+export function resolveWindowsCliPath(cliName, configuredPath) {
+    if (process.platform !== 'win32' || configuredPath !== cliName)
+        return configuredPath;
+    const npmPaths = [
+        join(process.env.APPDATA || '', 'npm', `${cliName}.cmd`),
+        join(process.env.LOCALAPPDATA || '', 'npm', `${cliName}.cmd`),
+    ];
+    for (const p of npmPaths) {
+        try {
+            accessSync(p, constants.F_OK);
+            return p;
+        }
+        catch {
+            /* try next */
+        }
+    }
+    return configuredPath;
+}

package/dist/config/file-io.d.ts

@@ -0,0 +1,11 @@
+import type { AiCommand, FileConfig } from './types.js';
+export declare const CONFIG_PATH: string;
+export declare const CODEX_AUTH_PATHS: string[];
+export declare function loadFileConfig(): FileConfig;
+export declare function saveFileConfig(raw: FileConfig): void;
+export declare function getClaudeConfigHome(): string;
+export declare function loadClaudeSettingsEnv(): Record<string, string>;
+export declare function saveClaudeSettingsEnv(env: Record<string, string>): void;
+export declare function normalizeAiCommand(value: unknown, fallback: AiCommand): AiCommand;
+export declare function hasCodexAuth(): boolean;
+export declare function parseCommaSeparated(value: string): string[];

package/dist/config/file-io.js

@@ -0,0 +1,176 @@
+import { readFileSync, writeFileSync, existsSync, mkdirSync, statSync, chmodSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { homedir } from 'node:os';
+import { createLogger } from '../logger.js';
+import { APP_HOME } from '../constants.js';
+const log = createLogger('config');
+export const CONFIG_PATH = join(APP_HOME, 'config.json');
+export const CODEX_AUTH_PATHS = [
+    join(homedir(), '.codex', 'auth.json'),
+    join(homedir(), '.config', 'codex', 'auth.json'),
+    join(homedir(), 'AppData', 'Roaming', 'codex', 'auth.json'),
+];
+const OLD_ROOT_KEYS = [
+    'claudeWorkDir',
+    'claudeTimeoutMs',
+    'claudeModel',
+];
+const AI_COMMANDS = ['claude', 'codex', 'codebuddy'];
+// Config cache with mtime tracking
+let cachedConfig = null;
+let cachedClaudeEnv = null;
+function hasOldConfigFormat(raw) {
+    const hasOld = OLD_ROOT_KEYS.some((k) => raw[k] !== undefined && raw[k] !== null);
+    const hasNew = raw.tools && typeof raw.tools === 'object' && raw.tools.claude;
+    return !!hasOld && !hasNew;
+}
+function migrateToNewConfigFormat(raw) {
+    const tools = raw.tools || {};
+    const tc = tools.claude || {};
+    const tcod = tools.codex || {};
+    const tcb = tools.codebuddy || {};
+    const migrated = { ...raw };
+    migrated.tools = {
+        claude: {
+            ...tc,
+            workDir: tc.workDir ?? raw.claudeWorkDir ?? process.cwd(),
+            proxy: tc.proxy,
+        },
+        codex: {
+            ...tcod,
+            cliPath: tcod.cliPath ?? 'codex',
+            workDir: tcod.workDir ?? raw.claudeWorkDir ?? process.cwd(),
+            proxy: tcod.proxy,
+        },
+        codebuddy: {
+            ...tcb,
+            cliPath: tcb.cliPath ?? 'codebuddy',
+        },
+    };
+    for (const k of OLD_ROOT_KEYS) {
+        delete migrated[k];
+    }
+    return migrated;
+}
+export function loadFileConfig() {
+    try {
+        if (!existsSync(CONFIG_PATH))
+            return {};
+        const stats = statSync(CONFIG_PATH);
+        const currentMtime = stats.mtimeMs;
+        if (cachedConfig && cachedConfig.mtime === currentMtime) {
+            return cachedConfig.config;
+        }
+        const raw = JSON.parse(readFileSync(CONFIG_PATH, 'utf-8'));
+        if (!raw || typeof raw !== 'object')
+            return {};
+        if (hasOldConfigFormat(raw)) {
+            const migrated = migrateToNewConfigFormat(raw);
+            const dir = dirname(CONFIG_PATH);
+            if (!existsSync(dir))
+                mkdirSync(dir, { recursive: true });
+            writeFileSync(CONFIG_PATH, JSON.stringify(migrated, null, 2), 'utf-8');
+            try {
+                chmodSync(CONFIG_PATH, 0o600);
+            }
+            catch { /* ignore */ }
+            cachedConfig = { config: migrated, mtime: currentMtime };
+            return migrated;
+        }
+        cachedConfig = { config: raw, mtime: currentMtime };
+        return raw;
+    }
+    catch {
+        return {};
+    }
+}
+export function saveFileConfig(raw) {
+    const dir = dirname(CONFIG_PATH);
+    if (!existsSync(dir))
+        mkdirSync(dir, { recursive: true });
+    writeFileSync(CONFIG_PATH, JSON.stringify(raw, null, 2), 'utf-8');
+    cachedConfig = null;
+}
+export function getClaudeConfigHome() {
+    return process.env.HOME || process.env.USERPROFILE || homedir();
+}
+export function loadClaudeSettingsEnv() {
+    const home = getClaudeConfigHome();
+    const paths = [
+        join(home, '.claude', 'settings.json'),
+        join(home, '.claude.json'),
+    ];
+    for (const p of paths) {
+        try {
+            if (existsSync(p)) {
+                const stats = statSync(p);
+                const currentMtime = stats.mtimeMs;
+                if (cachedClaudeEnv && cachedClaudeEnv.mtime === currentMtime && cachedClaudeEnv.env) {
+                    return cachedClaudeEnv.env;
+                }
+                const raw = JSON.parse(readFileSync(p, 'utf-8'));
+                const env = raw?.env;
+                if (env && typeof env === 'object') {
+                    const result = {};
+                    for (const [k, v] of Object.entries(env)) {
+                        if (v != null && typeof k === 'string') {
+                            result[k] = String(v);
+                        }
+                    }
+                    cachedClaudeEnv = { env: result, mtime: currentMtime };
+                    return result;
+                }
+            }
+        }
+        catch {
+            /* file not found or parse error, try next path */
+        }
+    }
+    return {};
+}
+export function saveClaudeSettingsEnv(env) {
+    const home = getClaudeConfigHome();
+    const claudeSettingsPath = join(home, '.claude', 'settings.json');
+    const claudeDir = join(home, '.claude');
+    try {
+        if (!existsSync(claudeDir)) {
+            mkdirSync(claudeDir, { recursive: true });
+        }
+        let existing = {};
+        if (existsSync(claudeSettingsPath)) {
+            try {
+                existing = JSON.parse(readFileSync(claudeSettingsPath, 'utf-8'));
+            }
+            catch {
+                // file format error, start fresh
+            }
+        }
+        existing.env = { ...existing.env, ...env };
+        writeFileSync(claudeSettingsPath, JSON.stringify(existing, null, 2), 'utf-8');
+        cachedClaudeEnv = null;
+    }
+    catch (error) {
+        log.error('Failed to save Claude settings:', error);
+        throw new Error(`Failed to save Claude settings: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+export function normalizeAiCommand(value, fallback) {
+    return typeof value === 'string' && AI_COMMANDS.includes(value)
+        ? value
+        : fallback;
+}
+export function hasCodexAuth() {
+    if (process.env.OPENAI_API_KEY)
+        return true;
+    return CODEX_AUTH_PATHS.some((p) => {
+        try {
+            return existsSync(p) && readFileSync(p, 'utf-8').trim().length > 0;
+        }
+        catch {
+            return false;
+        }
+    });
+}
+export function parseCommaSeparated(value) {
+    return value.split(',').map((s) => s.trim()).filter(Boolean);
+}

package/dist/config/types.d.ts

@@ -0,0 +1,177 @@
+import type { LogLevel } from '../logger.js';
+export type Platform = 'dingtalk' | 'feishu' | 'qq' | 'telegram' | 'wework' | 'workbuddy';
+export type AiCommand = 'claude' | 'codex' | 'codebuddy';
+export interface Config {
+    enabledPlatforms: Platform[];
+    telegramBotToken?: string;
+    feishuAppId?: string;
+    feishuAppSecret?: string;
+    weworkCorpId?: string;
+    weworkSecret?: string;
+    weworkWsUrl?: string;
+    dingtalkClientId?: string;
+    dingtalkClientSecret?: string;
+    dingtalkCardTemplateId?: string;
+    qqAppId?: string;
+    qqSecret?: string;
+    allowedUserIds: string[];
+    telegramAllowedUserIds: string[];
+    feishuAllowedUserIds: string[];
+    qqAllowedUserIds: string[];
+    weworkAllowedUserIds: string[];
+    dingtalkAllowedUserIds: string[];
+    workbuddyAllowedUserIds: string[];
+    aiCommand: AiCommand;
+    codexCliPath: string;
+    codebuddyCliPath: string;
+    /** Claude 访问 API 的代理（如 http://127.0.0.1:7890） */
+    claudeProxy?: string;
+    /** Codex 访问 chatgpt.com 的代理（如 http://127.0.0.1:7890） */
+    codexProxy?: string;
+    claudeWorkDir: string;
+    claudeModel?: string;
+    /** 是否跳过 AI 工具的权限确认（默认 true） */
+    skipPermissions?: boolean;
+    logDir: string;
+    logLevel: LogLevel;
+    platforms: {
+        telegram?: {
+            enabled: boolean;
+            aiCommand?: AiCommand;
+            proxy?: string;
+            allowedUserIds: string[];
+        };
+        feishu?: {
+            enabled: boolean;
+            aiCommand?: AiCommand;
+            allowedUserIds: string[];
+        };
+        qq?: {
+            enabled: boolean;
+            aiCommand?: AiCommand;
+            allowedUserIds: string[];
+        };
+        wework?: {
+            enabled: boolean;
+            aiCommand?: AiCommand;
+            allowedUserIds: string[];
+        };
+        dingtalk?: {
+            enabled: boolean;
+            aiCommand?: AiCommand;
+            allowedUserIds: string[];
+            cardTemplateId?: string;
+        };
+        workbuddy?: {
+            enabled: boolean;
+            aiCommand?: AiCommand;
+            allowedUserIds: string[];
+            accessToken?: string;
+            refreshToken?: string;
+            userId?: string;
+            baseUrl?: string;
+            guid?: string;
+            workspacePath?: string;
+        };
+    };
+}
+export interface FilePlatformTelegram {
+    enabled?: boolean;
+    botToken?: string;
+    aiCommand?: AiCommand;
+    allowedUserIds?: string[];
+    proxy?: string;
+}
+export interface FilePlatformFeishu {
+    enabled?: boolean;
+    appId?: string;
+    appSecret?: string;
+    aiCommand?: AiCommand;
+    allowedUserIds?: string[];
+}
+export interface FilePlatformQQ {
+    enabled?: boolean;
+    appId?: string;
+    secret?: string;
+    aiCommand?: AiCommand;
+    allowedUserIds?: string[];
+}
+export interface FilePlatformWechat {
+    enabled?: boolean;
+    aiCommand?: AiCommand;
+    userId?: string;
+    allowedUserIds?: string[];
+    workbuddyAccessToken?: string;
+    workbuddyRefreshToken?: string;
+    workbuddyBaseUrl?: string;
+    workbuddyHostId?: string;
+}
+export interface FilePlatformWework {
+    enabled?: boolean;
+    corpId?: string;
+    secret?: string;
+    aiCommand?: AiCommand;
+    wsUrl?: string;
+    allowedUserIds?: string[];
+}
+export interface FilePlatformDingtalk {
+    enabled?: boolean;
+    clientId?: string;
+    clientSecret?: string;
+    aiCommand?: AiCommand;
+    allowedUserIds?: string[];
+    cardTemplateId?: string;
+}
+export interface FilePlatformWorkBuddy {
+    enabled?: boolean;
+    aiCommand?: AiCommand;
+    allowedUserIds?: string[];
+    accessToken?: string;
+    refreshToken?: string;
+    userId?: string;
+    baseUrl?: string;
+    guid?: string;
+    workspacePath?: string;
+}
+export interface FileToolClaude {
+    cliPath?: string;
+    workDir?: string;
+    skipPermissions?: boolean;
+    /** HTTP/HTTPS 代理，用于访问 Claude API（如 http://127.0.0.1:7890） */
+    proxy?: string;
+    /** Claude API 配置（优先级：环境变量 > tools.claude.env > ~/.claude/settings.json） */
+    env?: Record<string, string>;
+}
+export interface FileToolCodex {
+    cliPath?: string;
+    workDir?: string;
+    /** HTTP/HTTPS 代理，用于访问 chatgpt.com（如 http://127.0.0.1:7890） */
+    proxy?: string;
+}
+export interface FileToolCodeBuddy {
+    cliPath?: string;
+}
+export interface FileConfig {
+    telegramBotToken?: string;
+    feishuAppId?: string;
+    feishuAppSecret?: string;
+    allowedUserIds?: string[];
+    platforms?: {
+        telegram?: FilePlatformTelegram;
+        feishu?: FilePlatformFeishu;
+        qq?: FilePlatformQQ;
+        wechat?: FilePlatformWechat;
+        wework?: FilePlatformWework;
+        dingtalk?: FilePlatformDingtalk;
+        workbuddy?: FilePlatformWorkBuddy;
+    };
+    env?: Record<string, string>;
+    aiCommand?: string;
+    tools?: {
+        claude?: FileToolClaude;
+        codex?: FileToolCodex;
+        codebuddy?: FileToolCodeBuddy;
+    };
+    logDir?: string;
+    logLevel?: LogLevel;
+}

package/dist/config/types.js

@@ -0,0 +1 @@
+export {};