work-agent 0.1.0

package/lib/feishu-auth.ts

@@ -0,0 +1,135 @@
+import axios from 'axios';
+
+const FEISHU_APP_ID = process.env.FEISHU_APP_ID || '';
+const FEISHU_APP_SECRET = process.env.FEISHU_APP_SECRET || '';
+const FEISHU_REDIRECT_URI = process.env.FEISHU_REDIRECT_URI || 
+  `http://work-agent.agent-platform.dev.aimstek.cn/api/auth/feishu/callback`;
+
+export interface FeishuUserInfo {
+	union_id: string;
+	open_id: string;
+	name: string;
+	avatar_url?: string;
+	avatar_thumb?: string;
+	avatar_middle?: string;
+	avatar_big?: string;
+}
+
+export interface FeishuTokenResponse {
+	access_token: string;
+	token_type: string;
+	expires_in: number;
+	refresh_token?: string;
+	scope?: string;
+}
+
+let cachedAppAccessToken: string | null = null;
+let appAccessTokenExpiresAt: number = 0;
+
+export function getFeishuLoginUrl(state?: string): string {
+	const params = new URLSearchParams({
+		app_id: FEISHU_APP_ID,
+		redirect_uri: FEISHU_REDIRECT_URI,
+		state: state || '',
+	});
+	return `https://open.feishu.cn/open-apis/authen/v1/index?${params.toString()}`;
+}
+
+export async function getAppAccessToken(): Promise<string> {
+	const now = Date.now();
+	if (cachedAppAccessToken && now < appAccessTokenExpiresAt) {
+		return cachedAppAccessToken;
+	}
+
+	const response = await axios.post(
+		'https://open.feishu.cn/open-apis/auth/v3/app_access_token/internal',
+		{
+			app_id: FEISHU_APP_ID,
+			app_secret: FEISHU_APP_SECRET,
+		},
+		{
+			headers: {
+				'Content-Type': 'application/json; charset=utf-8',
+			},
+		}
+	);
+
+	if (response.data.code !== 0) {
+		throw new Error(`获取app_access_token失败: ${response.data.msg} (code: ${response.data.code})`);
+	}
+
+	const data = response.data;
+	if (!data || !data.app_access_token) {
+		throw new Error(`获取app_access_token返回数据异常: ${JSON.stringify(data)}`);
+	}
+
+	cachedAppAccessToken = data.app_access_token;
+	appAccessTokenExpiresAt = Date.now() + (data.expire - 300) * 1000;
+
+	return cachedAppAccessToken!;
+}
+
+export async function getFeishuAccessToken(code: string): Promise<FeishuTokenResponse> {
+	const appAccessToken = await getAppAccessToken();
+
+	const response = await axios.post(
+		'https://open.feishu.cn/open-apis/authen/v1/oidc/access_token',
+		{
+			grant_type: 'authorization_code',
+			code,
+		},
+		{
+			headers: {
+				'Content-Type': 'application/json; charset=utf-8',
+				'Authorization': `Bearer ${appAccessToken}`,
+			},
+		}
+	);
+
+	if (response.data.code !== 0) {
+		throw new Error(`获取飞书access_token失败: ${response.data.msg} (code: ${response.data.code})`);
+	}
+
+	return response.data.data;
+}
+
+export async function getFeishuUserInfo(accessToken: string): Promise<FeishuUserInfo> {
+	const response = await axios.get(
+		'https://open.feishu.cn/open-apis/authen/v1/user_info',
+		{
+			headers: {
+				'Authorization': `Bearer ${accessToken}`,
+			},
+		}
+	);
+
+	if (response.data.code !== 0) {
+		throw new Error(`获取飞书用户信息失败: ${response.data.msg}`);
+	}
+
+	return response.data.data;
+}
+
+export async function refreshFeishuAccessToken(refreshToken: string): Promise<FeishuTokenResponse> {
+	const appAccessToken = await getAppAccessToken();
+
+	const response = await axios.post(
+		'https://open.feishu.cn/open-apis/authen/v1/oidc/refresh_access_token',
+		{
+			grant_type: 'refresh_token',
+			refresh_token: refreshToken,
+		},
+		{
+			headers: {
+				'Content-Type': 'application/json; charset=utf-8',
+				'Authorization': `Bearer ${appAccessToken}`,
+			},
+		}
+	);
+
+	if (response.data.code !== 0) {
+		throw new Error(`刷新飞书access_token失败: ${response.data.msg}`);
+	}
+
+	return response.data.data;
+}

package/lib/file-storage.ts

@@ -0,0 +1,306 @@
+import { mkdirSync, existsSync, writeFileSync, readFileSync, unlinkSync, statSync } from 'fs';
+import { join } from 'path';
+import { createHash } from 'crypto';
+import type { FileMetadata } from './db';
+
+export interface UploadFileOptions {
+	userId: string;
+	filename: string;
+	mimeType: string;
+	buffer: Buffer;
+}
+
+export interface StorageProvider {
+	upload(options: UploadFileOptions): Promise<{ storageKey: string; md5: string }>;
+	download(storageKey: string): Promise<Buffer>;
+	delete(storageKey: string): Promise<void>;
+	getUrl(storageKey: string): string;
+	exists(storageKey: string): boolean;
+	getSize(storageKey: string): number;
+}
+
+class LocalStorageProvider implements StorageProvider {
+	private baseDir: string;
+
+	constructor() {
+		this.baseDir = join(process.cwd(), 'data', 'users');
+		this.ensureBaseDir();
+	}
+
+	private ensureBaseDir() {
+		if (!existsSync(this.baseDir)) {
+			mkdirSync(this.baseDir, { recursive: true });
+		}
+	}
+
+	private getUserDir(userId: string): string {
+		const userDir = join(this.baseDir, userId, 'files');
+		if (!existsSync(userDir)) {
+			mkdirSync(userDir, { recursive: true });
+		}
+		return userDir;
+	}
+
+	async upload(options: UploadFileOptions): Promise<{ storageKey: string; md5: string }> {
+		const { userId, filename, buffer } = options;
+		const userDir = this.getUserDir(userId);
+
+		const md5 = createHash('md5').update(buffer).digest('hex');
+		const uuid = `${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+		const safeFilename = filename.replace(/[^a-zA-Z0-9\u4e00-\u9fa5._-]/g, '_');
+		const storageKey = `${uuid}_${safeFilename}`;
+
+		const filePath = join(userDir, storageKey);
+		writeFileSync(filePath, buffer);
+
+		return { storageKey, md5 };
+	}
+
+	async download(storageKey: string): Promise<Buffer> {
+		const parts = storageKey.split('_');
+		if (parts.length < 2) {
+			throw new Error('Invalid storage key format');
+		}
+
+		const userId = parts[0];
+		const userDir = this.getUserDir(userId);
+		const filePath = join(userDir, storageKey);
+
+		if (!existsSync(filePath)) {
+			throw new Error(`File not found: ${storageKey}`);
+		}
+
+		return readFileSync(filePath);
+	}
+
+	async delete(storageKey: string): Promise<void> {
+		const parts = storageKey.split('_');
+		if (parts.length < 2) {
+			throw new Error('Invalid storage key format');
+		}
+
+		const userId = parts[0];
+		const userDir = this.getUserDir(userId);
+		const filePath = join(userDir, storageKey);
+
+		if (existsSync(filePath)) {
+			unlinkSync(filePath);
+		}
+	}
+
+	getUrl(storageKey: string): string {
+		return `/api/my/files/${storageKey}`;
+	}
+
+	exists(storageKey: string): boolean {
+		try {
+			const parts = storageKey.split('_');
+			if (parts.length < 2) return false;
+
+			const userId = parts[0];
+			const userDir = this.getUserDir(userId);
+			const filePath = join(userDir, storageKey);
+
+			return existsSync(filePath);
+		} catch {
+			return false;
+		}
+	}
+
+	getSize(storageKey: string): number {
+		const parts = storageKey.split('_');
+		if (parts.length < 2) {
+			throw new Error('Invalid storage key format');
+		}
+
+		const userId = parts[0];
+		const userDir = this.getUserDir(userId);
+		const filePath = join(userDir, storageKey);
+
+		if (!existsSync(filePath)) {
+			throw new Error(`File not found: ${storageKey}`);
+		}
+
+		return statSync(filePath).size;
+	}
+}
+
+class LocalStorageProviderV2 implements StorageProvider {
+	private baseDir: string;
+
+	constructor() {
+		this.baseDir = join(process.cwd(), 'data', 'users');
+		this.ensureBaseDir();
+	}
+
+	private ensureBaseDir() {
+		if (!existsSync(this.baseDir)) {
+			mkdirSync(this.baseDir, { recursive: true });
+		}
+	}
+
+	private getUserDir(userId: string): string {
+		const userDir = join(this.baseDir, userId, 'files');
+		if (!existsSync(userDir)) {
+			mkdirSync(userDir, { recursive: true });
+		}
+		return userDir;
+	}
+
+	async upload(options: UploadFileOptions): Promise<{ storageKey: string; md5: string }> {
+		const { userId, filename, buffer } = options;
+		const userDir = this.getUserDir(userId);
+
+		const md5 = createHash('md5').update(buffer).digest('hex');
+		const uuid = `${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+		const safeFilename = filename.replace(/[^a-zA-Z0-9\u4e00-\u9fa5._-]/g, '_');
+		const storageKey = `${userId}/${uuid}_${safeFilename}`;
+
+		const filePath = join(userDir, `${uuid}_${safeFilename}`);
+		writeFileSync(filePath, buffer);
+
+		return { storageKey, md5 };
+	}
+
+	async download(storageKey: string): Promise<Buffer> {
+		const parts = storageKey.split('/');
+		if (parts.length < 2) {
+			throw new Error('Invalid storage key format');
+		}
+
+		const userId = parts[0];
+		const filename = parts.slice(1).join('/');
+		const userDir = this.getUserDir(userId);
+		const filePath = join(userDir, filename);
+
+		if (!existsSync(filePath)) {
+			throw new Error(`File not found: ${storageKey}`);
+		}
+
+		return readFileSync(filePath);
+	}
+
+	async delete(storageKey: string): Promise<void> {
+		const parts = storageKey.split('/');
+		if (parts.length < 2) {
+			throw new Error('Invalid storage key format');
+		}
+
+		const userId = parts[0];
+		const filename = parts.slice(1).join('/');
+		const userDir = this.getUserDir(userId);
+		const filePath = join(userDir, filename);
+
+		if (existsSync(filePath)) {
+			unlinkSync(filePath);
+		}
+	}
+
+	getUrl(storageKey: string): string {
+		const encodedKey = encodeURIComponent(storageKey);
+		return `/api/my/files/download?key=${encodedKey}`;
+	}
+
+	exists(storageKey: string): boolean {
+		try {
+			const parts = storageKey.split('/');
+			if (parts.length < 2) return false;
+
+			const userId = parts[0];
+			const filename = parts.slice(1).join('/');
+			const userDir = this.getUserDir(userId);
+			const filePath = join(userDir, filename);
+
+			return existsSync(filePath);
+		} catch {
+			return false;
+		}
+	}
+
+	getSize(storageKey: string): number {
+		const parts = storageKey.split('/');
+		if (parts.length < 2) {
+			throw new Error('Invalid storage key format');
+		}
+
+		const userId = parts[0];
+		const filename = parts.slice(1).join('/');
+		const userDir = this.getUserDir(userId);
+		const filePath = join(userDir, filename);
+
+		if (!existsSync(filePath)) {
+			throw new Error(`File not found: ${storageKey}`);
+		}
+
+		return statSync(filePath).size;
+	}
+}
+
+let storageProvider: StorageProvider | null = null;
+
+export function getStorageProvider(): StorageProvider {
+	if (!storageProvider) {
+		const storageType = process.env.FILE_STORAGE_TYPE || 'local';
+		switch (storageType) {
+			case 'local':
+			default:
+				storageProvider = new LocalStorageProviderV2();
+				break;
+		}
+	}
+	return storageProvider;
+}
+
+export function resetStorageProvider(): void {
+	storageProvider = null;
+}
+
+export const MAX_FILE_SIZE = 50 * 1024 * 1024;
+
+export const ALLOWED_MIME_TYPES = [
+	'image/jpeg',
+	'image/png',
+	'image/gif',
+	'image/webp',
+	'application/pdf',
+	'application/msword',
+	'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+	'application/vnd.ms-excel',
+	'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+	'application/vnd.ms-powerpoint',
+	'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+	'text/plain',
+	'text/csv',
+	'text/markdown',
+	'application/json',
+	'application/xml',
+	'text/html',
+	'text/css',
+	'application/javascript',
+	'text/javascript',
+	'application/zip',
+	'application/x-tar',
+	'application/gzip',
+	'application/x-gzip',
+];
+
+export function isAllowedMimeType(mimeType: string): boolean {
+	if (!mimeType || mimeType === '') return true;
+	return ALLOWED_MIME_TYPES.includes(mimeType) || 
+		mimeType.startsWith('text/') ||
+		mimeType.startsWith('image/') ||
+		mimeType === 'application/octet-stream';
+}
+
+export function getFileExtension(filename: string): string {
+	const parts = filename.split('.');
+	return parts.length > 1 ? parts.pop()?.toLowerCase() || '' : '';
+}
+
+export function formatFileSize(bytes: number): string {
+	if (bytes === 0) return '0 B';
+	const k = 1024;
+	const sizes = ['B', 'KB', 'MB', 'GB'];
+	const i = Math.floor(Math.log(bytes) / Math.log(k));
+	return `${parseFloat((bytes / Math.pow(k, i)).toFixed(2))} ${sizes[i]}`;
+}