work-ally 0.2.0-alpha.1

package/bridge/src/channels/feishu/normalize.ts

@@ -0,0 +1,368 @@
+import type { InboundMessage } from '../../types.ts';
+
+export interface FeishuEventSummary {
+  messageId: string;
+  conversationId: string;
+  chatType: string;
+  messageType: string;
+  senderType: string;
+  openId: string;
+  userId: string;
+  unionId: string;
+}
+
+interface CollectTextOptions {
+  includeMediaPlaceholders?: boolean;
+  parseJsonStrings?: boolean;
+}
+
+const DEFAULT_COLLECT_OPTIONS: Required<CollectTextOptions> = {
+  includeMediaPlaceholders: true,
+  parseJsonStrings: false,
+};
+
+const MERGE_FORWARD_COLLECT_OPTIONS: Required<CollectTextOptions> = {
+  includeMediaPlaceholders: false,
+  parseJsonStrings: true,
+};
+
+function parsePayload(content: string): unknown {
+  try {
+    return JSON.parse(content || '{}');
+  } catch {
+    return {};
+  }
+}
+
+function looksLikeJson(value: string): boolean {
+  const trimmed = value.trim();
+  return (trimmed.startsWith('{') && trimmed.endsWith('}'))
+    || (trimmed.startsWith('[') && trimmed.endsWith(']'));
+}
+
+function asRecord(value: unknown): Record<string, unknown> | null {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    return null;
+  }
+  return value as Record<string, unknown>;
+}
+
+function firstNonEmptyString(...values: unknown[]): string {
+  for (const value of values) {
+    if (typeof value === 'string' && value.trim()) {
+      return value.trim();
+    }
+  }
+  return '';
+}
+
+function pushSegment(segments: string[], value: string): void {
+  const trimmed = value.trim();
+  if (!trimmed) {
+    return;
+  }
+  if (segments[segments.length - 1] === trimmed) {
+    return;
+  }
+  segments.push(trimmed);
+}
+
+function collectRichTextSegments(value: unknown, options: CollectTextOptions = DEFAULT_COLLECT_OPTIONS): string[] {
+  const resolvedOptions = {
+    ...DEFAULT_COLLECT_OPTIONS,
+    ...options,
+  };
+
+  if (!value) {
+    return [];
+  }
+  if (typeof value === 'string') {
+    if (resolvedOptions.parseJsonStrings && looksLikeJson(value)) {
+      return collectRichTextSegments(parsePayload(value), resolvedOptions);
+    }
+    const trimmed = value.trim();
+    return trimmed ? [trimmed] : [];
+  }
+  if (Array.isArray(value)) {
+    const segments: string[] = [];
+    for (const item of value) {
+      for (const segment of collectRichTextSegments(item, resolvedOptions)) {
+        pushSegment(segments, segment);
+      }
+    }
+    return segments;
+  }
+  if (typeof value !== 'object') {
+    return [];
+  }
+
+  const record = value as Record<string, unknown>;
+  if (record.post && typeof record.post === 'object') {
+    return collectRichTextSegments(record.post, resolvedOptions);
+  }
+
+  const tag = typeof record.tag === 'string' ? record.tag : '';
+  if (tag === 'text') {
+    return collectRichTextSegments(record.text, resolvedOptions);
+  }
+  if (tag === 'md' || tag === 'markdown' || tag === 'lark_md') {
+    return collectRichTextSegments(record.text ?? record.content, resolvedOptions);
+  }
+  if (tag === 'a') {
+    const segments: string[] = [];
+    for (const part of collectRichTextSegments(record.text, resolvedOptions)) {
+      pushSegment(segments, part);
+    }
+    if (typeof record.href === 'string') {
+      pushSegment(segments, record.href);
+    }
+    return segments;
+  }
+  if (tag === 'at') {
+    if (typeof record.user_name === 'string' && record.user_name.trim()) {
+      return [`@${record.user_name.trim()}`];
+    }
+    if (typeof record.user_id === 'string' && record.user_id.trim()) {
+      return [`@${record.user_id.trim()}`];
+    }
+    return collectRichTextSegments(record.text, resolvedOptions);
+  }
+  if (tag === 'img') {
+    return resolvedOptions.includeMediaPlaceholders ? ['[image]'] : [];
+  }
+  if (tag === 'media') {
+    return resolvedOptions.includeMediaPlaceholders ? ['[media]'] : [];
+  }
+  if (tag === 'emotion') {
+    if (typeof record.emoji_type === 'string' && record.emoji_type.trim()) {
+      return [`:${record.emoji_type.trim()}:`];
+    }
+    return ['[emotion]'];
+  }
+
+  const segments: string[] = [];
+  for (const part of collectRichTextSegments(record.title, resolvedOptions)) {
+    pushSegment(segments, part);
+  }
+  for (const part of collectRichTextSegments(record.text, resolvedOptions)) {
+    pushSegment(segments, part);
+  }
+  if (typeof record.href === 'string') {
+    pushSegment(segments, record.href);
+  }
+  if (typeof record.url === 'string') {
+    pushSegment(segments, record.url);
+  }
+  for (const part of collectRichTextSegments(record.content, resolvedOptions)) {
+    pushSegment(segments, part);
+  }
+  for (const part of collectRichTextSegments(record.elements, resolvedOptions)) {
+    pushSegment(segments, part);
+  }
+
+  for (const [key, nested] of Object.entries(record)) {
+    if (['post', 'title', 'text', 'content', 'elements', 'tag', 'href', 'url'].includes(key)) {
+      continue;
+    }
+    for (const part of collectRichTextSegments(nested, resolvedOptions)) {
+      pushSegment(segments, part);
+    }
+  }
+  return segments;
+}
+
+function pushCollectedSegments(target: string[], value: unknown, options: CollectTextOptions): void {
+  for (const segment of collectRichTextSegments(value, options)) {
+    pushSegment(target, segment);
+  }
+}
+
+function extractStructuredTextFromValue(value: unknown, messageType = 'text', options: CollectTextOptions = DEFAULT_COLLECT_OPTIONS): string {
+  if (typeof value === 'string') {
+    const payload = parsePayload(value) as Record<string, unknown>;
+    const text = typeof payload.text === 'string'
+      ? payload.text
+      : typeof payload.content === 'string'
+        ? payload.content
+        : '';
+
+    if (messageType === 'interactive') {
+      const interactive = collectRichTextSegments(payload.elements ?? payload, options);
+      return interactive.join('\n').trim() || text.trim();
+    }
+
+    if (text.trim()) {
+      return text.trim();
+    }
+    return collectRichTextSegments(payload, options).join('\n').trim();
+  }
+
+  if (messageType === 'interactive') {
+    return collectRichTextSegments(value, options).join('\n').trim();
+  }
+  return collectRichTextSegments(value, options).join('\n').trim();
+}
+
+function extractMergeForwardItemText(value: unknown): string {
+  const item = asRecord(value);
+  if (!item) {
+    return collectRichTextSegments(value, MERGE_FORWARD_COLLECT_OPTIONS).join('\n').trim();
+  }
+
+  const body = asRecord(item.body);
+  const sender = firstNonEmptyString(
+    item.sender_name,
+    item.senderName,
+    body?.sender_name,
+    body?.senderName,
+    asRecord(item.sender)?.sender_name,
+    asRecord(item.sender)?.name,
+    asRecord(item.from)?.sender_name,
+    asRecord(item.from)?.name,
+  );
+  const messageType = firstNonEmptyString(
+    item.msg_type,
+    item.message_type,
+    body?.msg_type,
+    body?.message_type,
+  ) || 'text';
+
+  const text = extractStructuredTextFromValue(
+    body?.content ?? item.content ?? body?.elements ?? item.elements ?? body?.text ?? item.text,
+    messageType,
+    MERGE_FORWARD_COLLECT_OPTIONS,
+  );
+  if (text) {
+    return sender ? `${sender}: ${text}` : text;
+  }
+
+  const fallbackSegments: string[] = [];
+  pushCollectedSegments(fallbackSegments, item.title, MERGE_FORWARD_COLLECT_OPTIONS);
+  pushCollectedSegments(fallbackSegments, item.preview, MERGE_FORWARD_COLLECT_OPTIONS);
+  pushCollectedSegments(fallbackSegments, item.summary, MERGE_FORWARD_COLLECT_OPTIONS);
+  return fallbackSegments.join('\n').trim();
+}
+
+function extractMergeForwardText(value: unknown): string {
+  const payload = typeof value === 'string' ? parsePayload(value) : value;
+  const record = asRecord(payload);
+  if (!record) {
+    return collectRichTextSegments(payload, MERGE_FORWARD_COLLECT_OPTIONS).join('\n').trim();
+  }
+
+  const segments: string[] = [];
+  pushCollectedSegments(segments, record.title, MERGE_FORWARD_COLLECT_OPTIONS);
+  pushCollectedSegments(segments, record.summary, MERGE_FORWARD_COLLECT_OPTIONS);
+  pushCollectedSegments(segments, record.preview, MERGE_FORWARD_COLLECT_OPTIONS);
+  pushCollectedSegments(segments, record.preview_list, MERGE_FORWARD_COLLECT_OPTIONS);
+
+  const collections = [record.message_list, record.messages, record.items, record.messageList, record.messageListData];
+  for (const collection of collections) {
+    if (!Array.isArray(collection)) {
+      continue;
+    }
+    for (const item of collection) {
+      const itemText = extractMergeForwardItemText(item);
+      if (itemText) {
+        pushSegment(segments, itemText);
+      }
+    }
+  }
+
+  if (segments.length > 0) {
+    return segments.join('\n').trim();
+  }
+
+  return extractStructuredTextFromValue(
+    record.content ?? record.elements ?? record.post ?? record.preview,
+    'text',
+    MERGE_FORWARD_COLLECT_OPTIONS,
+  );
+}
+
+function unwrapEventEnvelope(event: any): any {
+  if (event?.event && typeof event.event === 'object') {
+    return event.event;
+  }
+  return event;
+}
+
+function readMessage(event: any): any {
+  return unwrapEventEnvelope(event)?.message;
+}
+
+function readSender(event: any): any {
+  return unwrapEventEnvelope(event)?.sender;
+}
+
+export function summarizeFeishuEvent(event: any): FeishuEventSummary {
+  const message = readMessage(event);
+  const sender = readSender(event);
+  const senderId = sender?.sender_id || {};
+  return {
+    messageId: message?.message_id || '',
+    conversationId: message?.chat_id || '',
+    chatType: message?.chat_type || '',
+    messageType: message?.message_type || '',
+    senderType: sender?.sender_type || '',
+    openId: senderId?.open_id || '',
+    userId: senderId?.user_id || '',
+    unionId: senderId?.union_id || '',
+  };
+}
+
+export function extractTextFromPayload(content: string, messageType = 'text'): string {
+  if (messageType === 'merge_forward') {
+    return extractMergeForwardText(content);
+  }
+  return extractStructuredTextFromValue(content, messageType, DEFAULT_COLLECT_OPTIONS);
+}
+
+export function isSupportedChatType(chatType: string | undefined): boolean {
+  return chatType === 'p2p' || chatType === 'single' || chatType === 'group';
+}
+
+export function extractFeishuMessageId(event: any): string {
+  return readMessage(event)?.message_id || '';
+}
+
+export function normalizeFeishuEvent(event: any, allowedUserIds: string[]): InboundMessage | null {
+  const message = readMessage(event);
+  const sender = readSender(event);
+  const senderId = sender?.sender_id?.open_id || '';
+  const messageId = message?.message_id || '';
+  const conversationId = message?.chat_id || '';
+  const messageType = message?.message_type || 'text';
+
+  if (sender?.sender_type === 'bot') {
+    return null;
+  }
+  if (!senderId || !messageId || !conversationId) {
+    return null;
+  }
+  if (!isSupportedChatType(message.chat_type)) {
+    return null;
+  }
+  if (allowedUserIds.length > 0 && !allowedUserIds.includes(senderId)) {
+    return null;
+  }
+
+  return {
+    messageId,
+    conversationRef: {
+      channel: 'feishu',
+      conversationId,
+      userId: senderId,
+      chatType: message.chat_type,
+    },
+    senderId,
+    senderName: sender?.sender_name || null,
+    text: extractTextFromPayload(message.content || '{}', messageType),
+    sourceMessageType: messageType,
+    replyToMessageId: message?.parent_id || null,
+    rootMessageId: message?.root_id || null,
+    replyToText: null,
+    receivedAt: new Date().toISOString(),
+    raw: event,
+  };
+}

package/bridge/src/codex-config.ts

@@ -0,0 +1,52 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+function resolveCodexHome(): string {
+  const explicit = process.env.CODEX_HOME;
+  if (explicit && explicit.trim()) {
+    return explicit.trim();
+  }
+  return path.join(os.homedir(), '.codex');
+}
+
+function redactLine(line: string): string {
+  const sensitivePattern = /(secret|token|api[_-]?key|password|credential|bearer|authorization)/i;
+  if (!line.includes('=') || !sensitivePattern.test(line)) {
+    return line;
+  }
+  const index = line.indexOf('=');
+  const key = line.slice(0, index + 1);
+  return `${key} "[REDACTED]"`;
+}
+
+function trimContent(content: string, maxLines = 200): string {
+  const lines = content.split(/\r?\n/);
+  if (lines.length <= maxLines) {
+    return content.trimEnd();
+  }
+  const kept = lines.slice(0, maxLines).join('\n').trimEnd();
+  return `${kept}\n... (truncated, total ${lines.length} lines)`;
+}
+
+export function loadCodexConfigPreview(): string {
+  const codexHome = resolveCodexHome();
+  const configPath = path.join(codexHome, 'config.toml');
+  if (!fs.existsSync(configPath)) {
+    return [
+      '未找到 Codex 配置文件。',
+      `path: ${configPath}`,
+      '如果你还没配置过 Codex，这是正常的。',
+    ].join('\n');
+  }
+
+  const raw = fs.readFileSync(configPath, 'utf8');
+  const sanitized = trimContent(raw.split(/\r?\n/).map((line) => redactLine(line)).join('\n'));
+  return [
+    '当前仅做只读查看；敏感字段已脱敏。',
+    `path: ${configPath}`,
+    '```toml',
+    sanitized,
+    '```',
+  ].join('\n');
+}

package/bridge/src/config.ts

@@ -0,0 +1,240 @@
+import path from 'node:path';
+import { ensureDir, loadDotEnv, mergeEnv, resolveTimeZone } from './utils.ts';
+
+
+export type CodexApprovalPolicy = 'untrusted' | 'on-failure' | 'on-request' | 'never';
+export type CodexSandboxMode = 'read-only' | 'workspace-write' | 'danger-full-access';
+
+export interface McpToolApprovalRule {
+  serverName: string;
+  toolName: string;
+}
+
+export interface WorkAllyConfig {
+  workspaceRoot: string;
+  stateDir: string;
+  implementationDir: string;
+  assistant: {
+    mode: 'assistant' | 'native';
+    name?: string;
+    assistantHome?: string;
+    codexHome?: string;
+  };
+  envFile: string;
+  runtime: {
+    mode: 'codex' | 'fake';
+    approvalPolicy: CodexApprovalPolicy;
+    sandboxMode: CodexSandboxMode;
+    mcpToolApprovalRules: McpToolApprovalRule[];
+  };
+  timezone: string;
+  channel: {
+    impl: 'feishu' | 'fake';
+    allowedUserIds: string[];
+  };
+  progressHeartbeatSeconds: number;
+  feishu: {
+    appId?: string;
+    appSecret?: string;
+    reactEmoji: string;
+  };
+  defaultPushTarget?: string;
+  logging: {
+    retentionDays: number;
+  };
+  paths: {
+    runtimeDir: string;
+    logsDir: string;
+    sessionsDir: string;
+    workSessionsDir: string;
+    runsDir: string;
+    cacheDir: string;
+    archiveDir: string;
+    dailyMemoryDir: string;
+    longTermMemoryDir: string;
+    routinesDir: string;
+    projectRoutinesDir: string;
+    conversationsDir: string;
+    assistantHome?: string;
+  };
+}
+
+
+const DEFAULT_MCP_TOOL_APPROVAL_ALLOWLIST = 'feishu:*';
+const APPROVAL_POLICIES = new Set<CodexApprovalPolicy>(['untrusted', 'on-failure', 'on-request', 'never']);
+const SANDBOX_MODES = new Set<CodexSandboxMode>(['read-only', 'workspace-write', 'danger-full-access']);
+
+function parseList(value: string | undefined): string[] {
+  return (value ?? '')
+    .split(',')
+    .map((item) => item.trim())
+    .filter(Boolean);
+}
+
+function parseApprovalPolicy(value: string | undefined): CodexApprovalPolicy {
+  const normalized = (value || 'on-request').trim() as CodexApprovalPolicy;
+  if (!APPROVAL_POLICIES.has(normalized)) {
+    throw new Error(`Invalid WORK_ALLY_CODEX_APPROVAL_POLICY: ${value}`);
+  }
+  return normalized;
+}
+
+function parseSandboxMode(value: string | undefined): CodexSandboxMode {
+  const normalized = (value || 'workspace-write').trim() as CodexSandboxMode;
+  if (!SANDBOX_MODES.has(normalized)) {
+    throw new Error(`Invalid WORK_ALLY_CODEX_SANDBOX_MODE: ${value}`);
+  }
+  return normalized;
+}
+
+function normalizeRulePart(value: string): string {
+  return value.trim().toLowerCase();
+}
+
+export function parseMcpToolApprovalRules(value: string | undefined): McpToolApprovalRule[] {
+  const raw = (value ?? DEFAULT_MCP_TOOL_APPROVAL_ALLOWLIST).trim();
+  if (!raw) {
+    return parseMcpToolApprovalRules(DEFAULT_MCP_TOOL_APPROVAL_ALLOWLIST);
+  }
+
+  if (['none', 'manual', '0'].includes(raw.toLowerCase())) {
+    return [];
+  }
+
+  return raw
+    .split(',')
+    .map((item) => item.trim())
+    .filter(Boolean)
+    .map((item) => {
+      const separator = item.indexOf(':');
+      const serverName = normalizeRulePart(separator === -1 ? item : item.slice(0, separator));
+      const toolName = normalizeRulePart(separator === -1 ? '*' : item.slice(separator + 1));
+      if (!serverName || !toolName) {
+        throw new Error(`Invalid WORK_ALLY_MCP_TOOL_APPROVAL_ALLOWLIST entry: ${item}`);
+      }
+      return { serverName, toolName };
+    });
+}
+
+export function formatMcpToolApprovalRules(rules: McpToolApprovalRule[]): string {
+  if (!rules.length) {
+    return 'manual all';
+  }
+  return `allow ${rules.map((rule) => `${rule.serverName}:${rule.toolName}`).join(', ')}; manual others`;
+}
+
+export function validateConfig(config: WorkAllyConfig): void {
+  new Intl.DateTimeFormat('en-US', { timeZone: config.timezone }).format(new Date());
+
+  if (!APPROVAL_POLICIES.has(config.runtime.approvalPolicy)) {
+    throw new Error(`Invalid WORK_ALLY_CODEX_APPROVAL_POLICY: ${config.runtime.approvalPolicy}`);
+  }
+
+  if (!SANDBOX_MODES.has(config.runtime.sandboxMode)) {
+    throw new Error(`Invalid WORK_ALLY_CODEX_SANDBOX_MODE: ${config.runtime.sandboxMode}`);
+  }
+
+  if (!Array.isArray(config.runtime.mcpToolApprovalRules)) {
+    throw new Error('Invalid WORK_ALLY_MCP_TOOL_APPROVAL_ALLOWLIST');
+  }
+
+  for (const rule of config.runtime.mcpToolApprovalRules) {
+    if (!rule?.serverName || !rule?.toolName) {
+      throw new Error('Invalid WORK_ALLY_MCP_TOOL_APPROVAL_ALLOWLIST');
+    }
+  }
+
+  if (config.channel.impl === 'feishu') {
+    if (!config.feishu.appId) {
+      throw new Error('FEISHU_APP_ID is required');
+    }
+    if (!config.feishu.appSecret) {
+      throw new Error('FEISHU_APP_SECRET is required');
+    }
+  }
+}
+
+export function loadConfig(): WorkAllyConfig {
+  const workspaceRoot = path.resolve(process.env.WORK_ALLY_WORKSPACE_ROOT || process.cwd());
+  const assistantHomeRaw = process.env.WORK_ALLY_ASSISTANT_HOME;
+  const defaultStateDir = assistantHomeRaw
+    ? path.join(assistantHomeRaw, '.system')
+    : path.join(workspaceRoot, '.work-ally');
+  const stateDir = path.resolve(process.env.WORK_ALLY_STATE_DIR || defaultStateDir);
+  const implementationDir = path.resolve(process.env.WORK_ALLY_IMPLEMENTATION_DIR || process.cwd());
+  const envFile = path.resolve(process.env.WORK_ALLY_ENV_FILE || path.join(stateDir, assistantHomeRaw ? 'config.env' : '.env'));
+  mergeEnv(loadDotEnv(envFile));
+
+  const assistantHome = assistantHomeRaw || undefined;
+  const stateRoot = stateDir;
+  const paths = assistantHome
+    ? {
+        runtimeDir: ensureDir(path.join(stateRoot, 'runtime')),
+        logsDir: ensureDir(path.join(stateRoot, 'logs')),
+        sessionsDir: ensureDir(path.join(stateRoot, 'runtime', 'sessions')),
+        workSessionsDir: ensureDir(path.join(stateRoot, 'runtime', 'work-sessions')),
+        runsDir: ensureDir(path.join(stateRoot, 'runs')),
+        cacheDir: ensureDir(path.join(stateRoot, 'cache')),
+        archiveDir: ensureDir(path.join(stateRoot, 'archive')),
+        dailyMemoryDir: ensureDir(path.join(assistantHome, 'journal')),
+        longTermMemoryDir: ensureDir(assistantHome),
+        routinesDir: ensureDir(path.join(stateRoot, 'routines')),
+        projectRoutinesDir: ensureDir(path.join(workspaceRoot, 'routines')),
+        conversationsDir: ensureDir(path.join(assistantHome, 'conversations')),
+        assistantHome,
+      }
+    : {
+        runtimeDir: ensureDir(path.join(stateRoot, 'runtime')),
+        logsDir: ensureDir(path.join(stateRoot, 'logs')),
+        sessionsDir: ensureDir(path.join(stateRoot, 'sessions')),
+        workSessionsDir: ensureDir(path.join(stateRoot, 'work-sessions')),
+        runsDir: ensureDir(path.join(stateRoot, 'runs')),
+        cacheDir: ensureDir(path.join(stateRoot, 'cache')),
+        archiveDir: ensureDir(path.join(workspaceRoot, 'memory/archive')),
+        dailyMemoryDir: ensureDir(path.join(workspaceRoot, 'memory/daily')),
+        longTermMemoryDir: ensureDir(path.join(workspaceRoot, 'memory/long-term')),
+        routinesDir: ensureDir(path.join(workspaceRoot, 'routines')),
+        projectRoutinesDir: ensureDir(path.join(workspaceRoot, 'routines')),
+        conversationsDir: ensureDir(path.join(stateRoot, 'sessions')),
+        assistantHome: undefined,
+      };
+
+
+  const config: WorkAllyConfig = {
+    workspaceRoot,
+    stateDir,
+    implementationDir,
+    assistant: {
+      mode: ((process.env.WORK_ALLY_ASSISTANT_MODE as 'assistant' | 'native') || (assistantHome ? 'assistant' : 'native')),
+      name: process.env.WORK_ALLY_ASSISTANT_NAME || undefined,
+      assistantHome,
+      codexHome: process.env.WORK_ALLY_ASSISTANT_CODEX_HOME || process.env.CODEX_HOME || undefined,
+    },
+    envFile,
+    runtime: {
+      mode: (process.env.WORK_ALLY_RUNTIME_MODE as 'codex' | 'fake') || 'codex',
+      approvalPolicy: parseApprovalPolicy(process.env.WORK_ALLY_CODEX_APPROVAL_POLICY),
+      sandboxMode: parseSandboxMode(process.env.WORK_ALLY_CODEX_SANDBOX_MODE),
+      mcpToolApprovalRules: parseMcpToolApprovalRules(process.env.WORK_ALLY_MCP_TOOL_APPROVAL_ALLOWLIST),
+    },
+    timezone: resolveTimeZone(process.env.WORK_ALLY_TIMEZONE),
+    channel: {
+      impl: (process.env.WORK_ALLY_CHANNEL_IMPL as 'feishu' | 'fake') || 'feishu',
+      allowedUserIds: parseList(process.env.WORK_ALLY_ALLOWED_USER_IDS),
+    },
+    progressHeartbeatSeconds: Number(process.env.WORK_ALLY_PROGRESS_HEARTBEAT_SECONDS || '60'),
+    feishu: {
+      appId: process.env.FEISHU_APP_ID,
+      appSecret: process.env.FEISHU_APP_SECRET,
+      reactEmoji: process.env.FEISHU_REACT_EMOJI || 'Typing',
+    },
+    defaultPushTarget: process.env.WORK_ALLY_DEFAULT_PUSH_TARGET || undefined,
+    logging: {
+      retentionDays: Number(process.env.WORK_ALLY_LOG_RETENTION_DAYS || '3'),
+    },
+    paths,
+  };
+
+  validateConfig(config);
+  return config;
+}