@myassis/gateway 1.0.0

package/README.md

@@ -0,0 +1,194 @@
+# 我的助手 Gateway 服务
+
+> 我的助手 项目的核心API网关服务，基于Express + TypeScript构建，提供统一的API接口、WebSocket实时通信、权限控制等能力。
+
+## ✨ 核心特性
+
+- 🚀 **高性能**：基于Express框架，轻量高效，支持高并发
+- 🔒 **安全可靠**：内置Helmet安全防护、CORS内网访问控制、JWT权限校验
+- 📡 **实时通信**：集成WebSocket服务，支持消息推送、实时通知
+- 🎯 **模块化设计**：路由、中间件、服务层分离，易于扩展和维护
+- 📦 **开箱即用**：内置用户认证、模型管理、技能管理、聊天、任务等核心API
+- ⚡ **开发友好**：TypeScript类型支持，热重载，完善的错误处理机制
+
+## 🛠️ 技术栈
+
+| 技术 | 版本 | 用途 |
+|------|------|------|
+| Node.js | >=18.x | 运行环境 |
+| Express | 4.x | Web框架 |
+| TypeScript | 5.x | 开发语言 |
+| WebSocket | - | 实时通信 |
+| SQLite | - | 本地数据存储 |
+| pnpm | 8.x | 包管理工具 |
+
+## 🚀 快速开始
+
+### 环境要求
+
+- Node.js >= 18.0.0
+- pnpm >= 8.0.0
+
+### 安装依赖
+
+```bash
+# 进入gateway目录
+cd gateway
+
+# 安装依赖
+pnpm install
+```
+
+### 开发模式运行
+
+```bash
+pnpm dev
+```
+
+服务启动后默认运行在 `http://localhost:3100`
+
+### 生产构建
+
+```bash
+pnpm build
+```
+
+### 生产运行
+
+```bash
+pnpm start
+```
+
+## 📁 项目结构
+
+```
+gateway/
+├── src/
+│   ├── api/                # 第三方API调用封装
+│   ├── config/             # 配置文件
+│   ├── middleware/         # 中间件（错误处理、权限校验等）
+│   ├── routes/             # 路由定义
+│   │   ├── auth.js         # 用户认证相关接口
+│   │   ├── agent.js        # AI代理相关接口
+│   │   ├── models.js       # 模型管理接口
+│   │   ├── skills.js       # 技能管理接口
+│   │   ├── skillHub.js     # 技能市场接口
+│   │   ├── chat.js         # 聊天相关接口
+│   │   ├── config.js       # 配置相关接口
+│   │   ├── settings.js     # 设置相关接口
+│   │   ├── tasks.js        # 任务管理接口
+│   │   └── upload.js       # 文件上传接口
+│   ├── services/           # 业务逻辑层
+│   │   └── WebSocketService.js # WebSocket服务
+│   ├── stores/             # 数据存储层
+│   ├── utils/              # 工具函数
+│   └── index.ts            # 服务入口文件
+├── migrations/             # 数据库迁移文件
+├── data/                   # 运行时数据存储目录
+├── dist/                   # 构建输出目录
+├── package.json
+├── tsconfig.json
+└── .npmrc
+```
+
+## 📡 API 接口
+
+所有接口都以 `/api/v1` 为前缀：
+
+| 接口前缀 | 说明 |
+|----------|------|
+| `/api/v1/auth` | 用户登录、登出、信息查询等认证相关接口 |
+| `/api/v1/agent` | AI代理执行、工具调用相关接口 |
+| `/api/v1/models` | 大语言模型的增删改查、配置管理 |
+| `/api/v1/skills` | 本地技能的安装、卸载、运行管理 |
+| `/api/v1/skill-hubs` | 技能市场搜索、安装、更新 |
+| `/api/v1/chats` | 聊天会话、消息管理 |
+| `/api/v1/config` | 系统配置获取、更新 |
+| `/api/v1/settings` | 用户设置管理 |
+| `/api/v1/tasks` | 定时任务、后台任务管理 |
+| `/api/v1/upload` | 文件上传、资源管理 |
+
+### 健康检查接口
+
+```
+GET /health
+```
+
+返回示例：
+```json
+{
+  "status": "ok",
+  "service": "gateway",
+  "version": "2.0.0",
+  "wsOnline": 1
+}
+```
+
+## ⚙️ 配置说明
+
+### CORS配置
+默认仅允许内网地址访问，支持的内网地址范围：
+- localhost
+- 127.x.x.x
+- 10.x.x.x
+- 172.16.x.x ~ 172.31.x.x
+- 192.168.x.x
+- *.local 域名
+
+### 端口配置
+默认端口为3100，可以通过修改 `src/config/index.js` 中的 `appConfig.port` 调整。
+
+### 上传限制
+请求体大小限制为10MB，支持大文件上传。
+
+## 🧩 WebSocket 服务
+
+服务启动时自动挂载WebSocket服务，支持：
+- 实时消息推送
+- 任务进度通知
+- AI代理执行状态同步
+- 系统事件广播
+
+连接地址：`ws://localhost:3100`
+
+## 🔧 开发指南
+
+### 新增API接口
+
+1. 在 `src/routes/` 下创建对应的路由文件
+2. 在 `src/index.ts` 中注册路由：
+```typescript
+import yourRoutes from './routes/yourRoutes.js';
+app.use('/api/v1/your-path', yourRoutes);
+```
+
+### 新增业务逻辑
+
+1. 在 `src/services/` 下创建对应的服务类
+2. 在路由中引入并调用服务方法
+
+### 数据库迁移
+
+新增数据模型时，在 `migrations/` 目录下添加迁移文件，启动时自动执行迁移。
+
+## 📝 常见问题
+
+### 端口被占用
+修改 `src/config/index.js` 中的端口配置，或者杀掉占用3100端口的进程：
+```bash
+npx kill-port 3100
+```
+
+### 跨域问题
+默认仅允许内网访问，如果需要开放外网访问，修改 `src/index.ts` 中的CORS配置。
+
+### 数据丢失
+所有运行时数据都保存在 `data/` 目录下，备份该目录即可完整备份所有数据。
+
+## 📄 许可证
+
+MIT License
+
+## 🤝 贡献
+
+欢迎提交Issue和Pull Request来改进这个项目！

package/dist/.env

@@ -0,0 +1,6 @@
+# Gateway 环境配置
+# Server API 地址（desktop 端通过 gateway 访问 server）
+SERVER_BASE_URL=https://api.my-assis.com
+# 服务端口
+PORT=3001
+HTTP_PROXY=http://127.0.0.1:7890

package/dist/api/index.js

@@ -0,0 +1,182 @@
+/**
+ * Gateway 统一 API 调用模块
+ * 负责与后端 Server 通信
+ * 自动从 authStore 获取 Token 并注入到请求头
+ *
+ * 服务端路由结构：
+ * - /api/v1/auth/*    - 认证路由
+ * - /api/v1/data/*    - 用户数据路由 (models, skills, tasks, settings)
+ * - /api/v1/skill-hubs/* - 技能库路由
+ */
+import crypto from 'crypto';
+import { authStore } from '../stores';
+// Server 服务地址（从环境变量读取）
+const SERVER_BASE_URL = process.env.SERVER_BASE_URL || 'http://localhost:3000';
+// 签名密钥（用于请求签名）
+const SIGN_KEY = process.env.API_SIGN_KEY || 'gateway-secret-key';
+// API 响应错误类
+export class ApiError extends Error {
+    status;
+    code;
+    constructor(message, status = 500, code) {
+        super(message);
+        this.name = 'ApiError';
+        this.status = status;
+        this.code = code;
+    }
+}
+// 生成签名
+function generateSignature(params, timestamp) {
+    const sortedParams = Object.keys(params)
+        .sort()
+        .map(key => `${key}=${params[key]}`)
+        .join('&');
+    const signString = `${sortedParams}&timestamp=${timestamp}&key=${SIGN_KEY}`;
+    return crypto.createHash('sha256').update(signString).digest('hex');
+}
+// 基础请求方法工厂
+// prefix: 路由前缀，如 '/api/v1/auth', '/api/v1/data', '/api/v1/skill-hubs'
+function createRequest(prefix) {
+    return async function (path, options = {}) {
+        const { method = 'GET', body, headers = {}, params, skipAuth = false } = options;
+        // 构建 URL
+        let url = `${SERVER_BASE_URL}${prefix}${path}`;
+        // 添加查询参数
+        if (params) {
+            const queryString = Object.entries(params)
+                .filter(([_, v]) => v !== undefined && v !== null)
+                .map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(v)}`)
+                .join('&');
+            if (queryString) {
+                url += `?${queryString}`;
+            }
+        }
+        // 生成时间戳和签名
+        const timestamp = Date.now().toString();
+        const signParams = {};
+        const signature = generateSignature(signParams, timestamp);
+        // 构建请求头
+        const requestHeaders = {
+            'Content-Type': 'application/json',
+            'X-Gateway-Timestamp': timestamp,
+            'X-Gateway-Signature': signature,
+            ...headers
+        };
+        // 自动注入 Token（除非明确跳过）
+        if (!skipAuth) {
+            const token = authStore.getToken();
+            if (token) {
+                requestHeaders['Authorization'] = `Bearer ${token}`;
+            }
+        }
+        try {
+            const response = await fetch(url, {
+                method,
+                headers: requestHeaders,
+                body: body ? JSON.stringify(body) : undefined
+            });
+            const data = await response.json();
+            if (!response.ok) {
+                throw new ApiError(data.message || data.error || '请求失败', response.status, data.code);
+            }
+            return data;
+        }
+        catch (error) {
+            if (error instanceof ApiError) {
+                throw error;
+            }
+            throw new ApiError('网络请求失败', 500, 'NETWORK_ERROR');
+        }
+    };
+}
+// 创建不同前缀的请求方法
+const authRequest = createRequest('/api/v1/auth'); // /api/v1/auth/*
+const dataRequest = createRequest('/api/v1/data'); // /api/v1/data/*
+const skillHubRequest = createRequest('/api/v1/skill-hubs'); // /api/v1/skill-hubs/*
+// ============ 认证 API ============
+export const authApi = {
+    login: (data) => authRequest('/login', { method: 'POST', body: data, skipAuth: true }),
+    register: (data) => authRequest('/register', { method: 'POST', body: data, skipAuth: true }),
+    logout: () => authRequest('/logout', { method: 'POST', body: {} }),
+    refresh: (refreshToken) => authRequest('/refresh', { method: 'POST', body: { refreshToken }, skipAuth: true }),
+    me: () => authRequest('/me'),
+    updateProfile: (data) => authRequest('/profile', { method: 'PUT', body: data }),
+    changePassword: (data) => authRequest('/password', { method: 'PUT', body: data }),
+    deleteAccount: (data, token) => {
+        const headers = {};
+        if (token)
+            headers['Authorization'] = `Bearer ${token}`;
+        return authRequest('/account/delete', { method: 'POST', body: data, headers });
+    },
+};
+// ============ 技能 API (data) ============
+export const skillsApi = {
+    list: () => dataRequest('/skills?brief=true'),
+    get: (skillId) => dataRequest(`/skills/${skillId}`),
+    install: (data) => dataRequest('/skills', { method: 'POST', body: data }),
+    create: (data) => dataRequest('/skills', { method: 'POST', body: data }),
+    update: (skillId, data) => dataRequest(`/skills/${skillId}`, { method: 'PUT', body: data }),
+    uninstall: (skillId) => dataRequest(`/skills/${skillId}`, { method: 'DELETE' }),
+    setApiKey: (skillId, data) => dataRequest(`/skills/${skillId}/api-key`, { method: 'POST', body: data }),
+    rate: (skillId, data) => dataRequest(`/skills/${skillId}/rating`, { method: 'POST', body: data }),
+    parse: (data) => dataRequest('/skills/parse', { method: 'POST', body: data }),
+};
+// ============ 技能库 API (skill-hubs) ============
+export const skillHubApi = {
+    list: (params) => {
+        const queryParams = {};
+        if (params?.page)
+            queryParams.page = String(params.page);
+        if (params?.pageSize)
+            queryParams.pageSize = String(params.pageSize);
+        if (params?.keyword)
+            queryParams.keyword = params.keyword;
+        if (params?.category)
+            queryParams.category = params.category;
+        return skillHubRequest('/', { params: queryParams });
+    },
+    get: (hubId) => skillHubRequest(`/${hubId}`),
+    categories: () => skillHubRequest('/categories'),
+    preinstalled: () => skillHubRequest('/preinstalled'),
+    user: () => skillHubRequest(`/user`),
+    checkUsed: (hubId) => skillHubRequest(`/${hubId}/used`),
+    rate: (hubId, rating) => skillHubRequest(`/${hubId}/rate`, { method: 'POST', body: { rating } }),
+    userRating: (hubId) => skillHubRequest(`/${hubId}/user-rating`),
+    install: (hubId) => skillHubRequest(`/${hubId}/install`, { method: 'POST', body: {} }),
+    use: (hubId) => skillHubRequest(`/${hubId}/use`, { method: 'POST', body: {} }),
+};
+// ============ 模型 API (data) ============
+export const modelsApi = {
+    list: () => dataRequest('/models'),
+    get: (modelId) => dataRequest(`/models/${modelId}`),
+    create: (data) => dataRequest('/models', { method: 'POST', body: data }),
+    update: (modelId, data) => dataRequest(`/models/${modelId}`, { method: 'PUT', body: data }),
+    delete: (modelId) => dataRequest(`/models/${modelId}`, { method: 'DELETE' }),
+    setPrimary: (modelId) => dataRequest(`/models/${modelId}/primary`, { method: 'POST', body: {} }),
+};
+// ============ 任务 API (data) ============
+export const tasksApi = {
+    list: (params) => dataRequest('/tasks', { params }),
+    get: (taskId) => dataRequest(`/tasks/${taskId}`),
+    create: (data) => dataRequest('/tasks', { method: 'POST', body: data }),
+    update: (taskId, data) => dataRequest(`/tasks/${taskId}`, { method: 'PUT', body: data }),
+    delete: (taskId) => dataRequest(`/tasks/${taskId}`, { method: 'DELETE' }),
+    complete: (taskId) => dataRequest(`/tasks/${taskId}/complete`, { method: 'POST', body: {} }),
+    cancel: (taskId) => dataRequest(`/tasks/${taskId}/cancel`, { method: 'POST', body: {} }),
+    updateStatus: (taskId, data) => dataRequest(`/tasks/${taskId}/status`, { method: 'POST', body: data }),
+    notifying: () => dataRequest('/tasks/notifying'),
+    resetSession: () => dataRequest('/reset-session', { method: 'POST', body: {} }),
+};
+// ============ 设置 API (data) ============
+export const settingsApi = {
+    get: () => dataRequest('/settings'),
+    update: (data) => dataRequest('/settings', { method: 'PUT', body: data }),
+};
+export default {
+    authApi,
+    skillsApi,
+    skillHubApi,
+    modelsApi,
+    tasksApi,
+    settingsApi
+};

package/dist/config/index.js

@@ -0,0 +1,41 @@
+import { getLogger } from '@pocketclaw/shared';
+const logger = getLogger('GatewayConfig');
+import { config as dotenvConfig } from 'dotenv';
+import * as path from 'path';
+import * as fs from 'fs';
+// 打包后从可执行文件所在目录读取 .env，开发时从 CWD 读取
+const getEnvPath = () => {
+    // pkg 打包后用 process.execPath 获取 exe 所在目录
+    const exeDir = path.dirname(process.execPath);
+    const exeEnvPath = path.join(exeDir, '.env');
+    if (fs.existsSync(exeEnvPath)) {
+        return exeEnvPath;
+    }
+    // 开发环境：从 CWD 读取
+    const cwdEnvPath = path.resolve(process.cwd(), '.env');
+    if (fs.existsSync(cwdEnvPath)) {
+        return cwdEnvPath;
+    }
+    return undefined;
+};
+const envPath = getEnvPath();
+if (envPath) {
+    dotenvConfig({ path: envPath });
+    logger.info(`已加载环境变量文件: ${envPath}`);
+}
+else {
+    logger.info('未找到 .env 文件，使用系统环境变量');
+}
+// pkg 打包后自动设为 production
+const isPackaged = !!process.pkg;
+const defaultEnv = isPackaged ? 'production' : 'development';
+// 环境变量配置
+export const appConfig = {
+    serverBaseUrl: process.env.SERVER_BASE_URL || 'http://localhost:9091',
+    port: parseInt(process.env.PORT || '3001', 10),
+    clientUrl: process.env.CLIENT_URL || 'http://localhost:3000',
+    nodeEnv: process.env.NODE_ENV || defaultEnv,
+    messageKeep: 4,
+    appName: 'MyClaw'
+};
+export default appConfig;

package/dist/index.js

@@ -0,0 +1,183 @@
+import express from 'express';
+import cors from 'cors';
+import helmet from 'helmet';
+import compression from 'compression';
+import http from 'http';
+import { appConfig } from './config/index.js';
+import { getLogger } from '@pocketclaw/shared';
+import authRoutes from './routes/auth.js';
+import agentRoutes from './routes/agent.js';
+import modelsRoutes from './routes/models.js';
+import skillsRoutes from './routes/skills.js';
+import skillHubRoutes from './routes/skillHub.js';
+import chatRoutes from './routes/chat.js';
+import configRoutes from './routes/config.js';
+import settingsRoutes from './routes/settings.js';
+import serviceRoutes from './routes/service.js';
+import tasksRoutes from './routes/tasks.js';
+import uploadRoutes from './routes/upload.js';
+import versionRoutes from './routes/version.js';
+import { errorHandler } from './middleware/errorHandler.js';
+import { authStore } from './stores/index.js';
+import { webSocketService } from './services/WebSocketService.js';
+import { taskSchedulerService } from './services/TaskSchedulerService.js';
+import { getServiceInfo, installService, uninstallService, startService, stopService, updateService, } from './services/ServiceManager.js';
+const logger = getLogger('index');
+// ─── CLI 模式 ─────────────────────────────────────────
+// gateway install | start | stop | uninstall | status | update
+const cliCommand = process.argv[2];
+if (cliCommand) {
+    (async () => {
+        try {
+            let exitCode = 0;
+            if (cliCommand === 'status') {
+                const info = await getServiceInfo();
+                console.log(`服务名称: ${info.displayName}`);
+                console.log(`平台: ${info.platform}`);
+                console.log(`已安装: ${info.installed ? '是' : '否'}`);
+                console.log(`运行中: ${info.running ? '是' : '否'}`);
+                if (!info.canManage)
+                    console.log(`(当前平台不支持服务管理)`);
+            }
+            else {
+                const fnMap = {
+                    install: installService,
+                    uninstall: uninstallService,
+                    start: startService,
+                    stop: stopService,
+                    update: updateService,
+                };
+                const handler = fnMap[cliCommand];
+                if (!handler) {
+                    console.log(`未知命令: ${cliCommand}\n可用命令: install | start | stop | uninstall | status | update`);
+                    process.exit(1);
+                }
+                const result = await handler();
+                console.log(result.success ? `✅ ${result.message}` : `❌ ${result.message}`);
+                if (!result.success)
+                    exitCode = 1;
+            }
+            process.exit(exitCode);
+        }
+        catch (err) {
+            console.error(`❌ 操作失败: ${err.message}`);
+            process.exit(1);
+        }
+    })();
+    // CLI 命令执行 process.exit() 后脚本终止，IIFE 异步执行不阻塞
+    // 不写 return，让脚本自然结束（IIFE 完成后进程也退了）
+}
+else {
+    // ─── HTTP Server 模式 ────────────────────────────────────
+    const app = express();
+    // Middleware
+    app.use(helmet());
+    app.use(compression());
+    // CORS 配置 - 允许所有内网地址
+    const corsOptions = {
+        origin: (origin, callback) => {
+            // 允许没有 origin 的请求（如移动端或同源请求）
+            if (!origin) {
+                return callback(null, true);
+            }
+            // 内网地址正则
+            const lanPatterns = [
+                /^http:\/\/localhost(:\d+)?$/,
+                /^http:\/\/127\.\d+\.\d+\.\d+(:\d+)?$/,
+                /^http:\/\/10\.\d+\.\d+\.\d+(:\d+)?$/,
+                /^http:\/\/172\.(1[6-9]|2\d|3[01])\.\d+\.\d+(:\d+)?$/,
+                /^http:\/\/192\.168\.\d+\.\d+(:\d+)?$/,
+                /^http:\/\/\d+\.\d+\.\d+\.\d+(:\d+)?$/,
+                /\.local(:\d+)?$/,
+            ];
+            if (lanPatterns.some(pattern => pattern.test(origin))) {
+                return callback(null, true);
+            }
+            callback(new Error('Not allowed by CORS'));
+        },
+        credentials: true,
+    };
+    app.use(cors(corsOptions));
+    app.use(express.json({ limit: '10mb' }));
+    // Health check
+    app.get('/health', (req, res) => {
+        res.json({ status: 'ok', service: 'gateway', version: '2.0.0', wsOnline: webSocketService.getOnlineCount() });
+    });
+    // Routes
+    app.use('/api/v1/auth', authRoutes);
+    app.use('/api/v1/agent', agentRoutes);
+    app.use('/api/v1/models', modelsRoutes);
+    app.use('/api/v1/skills', skillsRoutes);
+    app.use('/api/v1/skill-hubs', skillHubRoutes);
+    app.use('/api/v1/chats', chatRoutes);
+    app.use('/api/v1/config', configRoutes);
+    app.use('/api/v1/settings', settingsRoutes);
+    app.use('/api/v1/service', serviceRoutes);
+    app.use('/api/v1/tasks', tasksRoutes);
+    app.use('/api/v1/upload', uploadRoutes);
+    app.use('/api/v1/version', versionRoutes);
+    // Load auth from persistent storage on startup
+    authStore.load();
+    // Error handler
+    app.use(errorHandler);
+    // 创建 HTTP Server（而非 app.listen，以便挂载 WebSocket）
+    const server = http.createServer(app);
+    // 初始化 WebSocket 服务
+    webSocketService.initialize(server);
+    // 启动任务调度器
+    taskSchedulerService.start();
+    // 端口自动顺延：被占用时自动尝试下一个端口
+    const startServer = (port) => {
+        server.listen(port, () => {
+            // 动态更新 appConfig.port（供 WebSocket 广播实际端口）
+            appConfig.port = port;
+            if (port !== appConfig.port) {
+                logger.info(`Port ${appConfig.port} is in use, fallback to port ${port}`);
+            }
+            logger.info(`MyClaw Gateway Service running on port ${port}`);
+            if (authStore.isAuthenticated()) {
+                const user = authStore.getUser();
+                logger.info(`User logged in: ${user?.nickname || user?.email} (ID: ${user?.id})`);
+            }
+            else {
+                logger.info(`No user logged in`);
+            }
+        }).on('error', (err) => {
+            if (err.code === 'EADDRINUSE') {
+                const nextPort = port + 1;
+                if (nextPort <= (appConfig.port + 10)) {
+                    logger.warn(`Port ${port} is in use, trying ${nextPort}...`);
+                    startServer(nextPort);
+                }
+                else {
+                    logger.error(`All ports from ${appConfig.port} to ${appConfig.port + 10} are in use`);
+                    process.exit(1);
+                }
+            }
+            else {
+                logger.error(`Server error: ${err.message}`);
+                process.exit(1);
+            }
+        });
+    };
+    startServer(appConfig.port);
+    // 优雅关闭
+    process.on('SIGTERM', () => {
+        logger.info('收到 SIGTERM，正在关闭...');
+        webSocketService.shutdown();
+        taskSchedulerService.stop();
+        server.close(() => {
+            logger.info('服务已关闭');
+            process.exit(0);
+        });
+    });
+    process.on('SIGINT', () => {
+        logger.info('收到 SIGINT，正在关闭...');
+        webSocketService.shutdown();
+        taskSchedulerService.stop();
+        server.close(() => {
+            logger.info('服务已关闭');
+            process.exit(0);
+        });
+    });
+}

package/dist/middleware/auth.js

@@ -0,0 +1,53 @@
+import jwt from 'jsonwebtoken';
+const JWT_SECRET = process.env.JWT_SECRET || 'your-secret-key-change-in-production';
+/**
+ * 从请求头提取 Bearer token
+ */
+function extractToken(req) {
+    const auth = req.headers.authorization;
+    if (typeof auth === 'string' && auth.startsWith('Bearer ')) {
+        return auth.slice(7);
+    }
+    return undefined;
+}
+/**
+ * 解码 JWT，提取 userId
+ */
+function decodeUserId(token) {
+    try {
+        const payload = jwt.verify(token, JWT_SECRET);
+        return payload.userId;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * 需要认证：token 无效返回 401
+ */
+export function requireAuth(req, res, next) {
+    const token = extractToken(req);
+    if (!token) {
+        res.status(401).json({ success: false, error: 'Unauthorized' });
+        return;
+    }
+    const userId = decodeUserId(token);
+    if (!userId) {
+        res.status(401).json({ success: false, error: 'Unauthorized' });
+        return;
+    }
+    req.userId = userId;
+    req.token = token;
+    next();
+}
+/**
+ * 可选认证：token 存在则解码，不存在也放行
+ */
+export function optionalAuth(req, _res, next) {
+    const token = extractToken(req);
+    if (token) {
+        req.userId = decodeUserId(token);
+        req.token = token;
+    }
+    next();
+}

package/dist/middleware/errorHandler.js

@@ -0,0 +1,20 @@
+import { getLogger } from '@pocketclaw/shared';
+const logger = getLogger('ErrorHandler');
+export const errorHandler = (err, req, res, next) => {
+    logger.error('[Gateway Error]', err.message, err.stack);
+    const statusCode = err.statusCode || 500;
+    const message = err.message || 'Internal Server Error';
+    res.status(statusCode).json({
+        error: {
+            message,
+            code: err.code,
+            status: statusCode
+        }
+    });
+};
+export const createError = (message, statusCode, code) => {
+    const error = new Error(message);
+    error.statusCode = statusCode;
+    error.code = code;
+    return error;
+};