glad-web 1.0.45 → 1.0.46

package/lib/codex/structured-session.js

@@ -330,6 +330,11 @@ class CodexStructuredSession extends EventEmitter {
     this.timedInputs = new Map();
     this.promptHistoryCache = null;
     this.deferredWarnings = null;
+    this.activeSkill = options.activeSkill && options.activeSkill.name && options.activeSkill.path
+      ? { name: String(options.activeSkill.name), path: String(options.activeSkill.path) }
+      : null;
+    this.extraSkillRoots = (Array.isArray(options.extraSkillRoots) ? options.extraSkillRoots : [])
+      .map(value => String(value || '').trim()).filter(Boolean);
   }
 
   toListItem() {
@@ -540,6 +545,9 @@ class CodexStructuredSession extends EventEmitter {
           }, { fatalOnTimeout: true });
         }).then(async () => {
           this.notify('initialized', {});
+          if (this.extraSkillRoots.length) {
+            await this.request('skills/extraRoots/set', { extraRoots: this.extraSkillRoots }, { fatalOnTimeout: true });
+          }
           try { await this.refreshConfigDefaults(); } catch (error) { this.logger.debugInfo?.(`[codex-app-server] config/read failed: ${error.message}`); }
           try { await this.refreshModels(); } catch (error) { this.logger.debugInfo?.(`[codex-app-server] model/list failed: ${error.message}`); }
           resolve();
@@ -908,10 +916,11 @@ class CodexStructuredSession extends EventEmitter {
 
   async listSkills(forceReload = false) {
     await this.ensureProcess();
-    const result = await this.request('skills/list', {
+    const params = {
       cwds: [this.workingDir],
       forceReload: Boolean(forceReload)
-    });
+    };
+    const result = await this.request('skills/list', params);
     const entries = Array.isArray(result?.data) ? result.data : [];
     const entry = entries.find(item => item?.cwd === this.workingDir) || entries[0] || {};
     return {
@@ -921,7 +930,10 @@ class CodexStructuredSession extends EventEmitter {
   }
 
   async resolveSkillInputs(skills) {
-    const requested = (Array.isArray(skills) ? skills : []).slice(0, 8);
+    const requested = [
+      ...(this.activeSkill ? [this.activeSkill] : []),
+      ...(Array.isArray(skills) ? skills : [])
+    ].slice(0, 8);
     if (!requested.length) return [];
     const available = await this.listSkills(false);
     const allowed = new Map(available.skills.map(item => [`${item.name}\n${item.path}`, item]));

package/lib/commands/web.js

@@ -48,10 +48,14 @@ const registerWorkspaceRoutes = require('../server/routes/workspace');
 const registerProviderRoutes = require('../server/routes/providers');
 const registerNotificationRoutes = require('../server/routes/notifications');
 const registerUsageRoutes = require('../server/routes/usage');
+const registerSkillHubRoutes = require('../server/routes/skillhub');
 const { UsageService } = require('../usage/usage-service');
 const { ServerChanSettingsStore } = require('../notifications/serverchan-settings-store');
 const ServerChanClient = require('../notifications/serverchan-client');
 const NotificationService = require('../notifications/notification-service');
+const { SkillHubSettingsStore } = require('../skillhub/settings-store');
+const { SkillHubClient } = require('../skillhub/client');
+const { SkillInstaller } = require('../skillhub/skill-installer');
 
 async function webCommand(options) {
   const port = parseInt(options.port) || 3000;
@@ -104,6 +108,10 @@ async function webCommand(options) {
     logger
   });
   const usageService = new UsageService({ logger });
+  const skillHubSettings = new SkillHubSettingsStore();
+  const skillHubClient = new SkillHubClient({ settingsStore: skillHubSettings });
+  const skillInstaller = new SkillInstaller({ client: skillHubClient });
+  await skillInstaller.initialize();
   sessionManager.on('output', ({ sessionId, data }) => {
     broadcastToSession(sessionId, { type: 'output', data });
   });
@@ -147,6 +155,12 @@ async function webCommand(options) {
     notificationService
   });
   registerUsageRoutes(app, { usageService, sendJson: sendCompressedJson });
+  registerSkillHubRoutes(app, {
+    settingsStore: skillHubSettings,
+    client: skillHubClient,
+    installer: skillInstaller,
+    sessionManager
+  });
 
   // API: List all active sessions
   app.get('/api/sessions', (req, res) => {
@@ -310,7 +324,8 @@ async function webCommand(options) {
 
   // API: Delete/Kill session
   app.delete('/api/sessions/:id', async (req, res) => {
-    await sessionManager.kill(req.params.id);
+    const deleted = await sessionManager.kill(req.params.id);
+    if (!deleted) return res.status(404).json({ error: 'Session not found' });
     res.json({ success: true });
   });
 
@@ -509,12 +524,14 @@ async function webCommand(options) {
   };
 
   const webAssets = [
+    'bootstrap.js',
     'gitgraph.js',
     'styles.css',
     'theme.js',
     'core.js',
     'layout.js',
     'notifications.js',
+    'skillhub.js',
     'claude.js',
     'schedules.js',
     'shell.js',
@@ -575,12 +592,14 @@ async function webCommand(options) {
     console.log(chalk.gray(`Tips: Access from your phone via the Network URL above.\n`));
   });
 
-  process.on('SIGINT', () => { 
+  const shutdown = () => {
     schedulerService.stop();
     notificationService.stop();
     sessionManager.killAll();
-    process.exit(0); 
-  });
+    process.exit(0);
+  };
+  process.once('SIGINT', shutdown);
+  process.once('SIGTERM', shutdown);
 }
 
 module.exports = webCommand;

package/lib/config/manager.js

@@ -26,6 +26,25 @@ const schema = {
       clientType: 'wechat'
     }
   },
+  skillHub: {
+    type: 'object',
+    properties: {
+      baseUrl: { type: 'string', default: '' },
+      token: {
+        type: 'object',
+        properties: {
+          ciphertext: { type: 'string', default: '' },
+          iv: { type: 'string', default: '' },
+          authTag: { type: 'string', default: '' }
+        },
+        default: { ciphertext: '', iv: '', authTag: '' }
+      }
+    },
+    default: {
+      baseUrl: '',
+      token: { ciphertext: '', iv: '', authTag: '' }
+    }
+  },
   version: {
     type: 'string',
     default: '1.0.0'

package/lib/server/routes/skillhub.js

@@ -0,0 +1,104 @@
+const { v4: uuidv4 } = require('uuid');
+
+function statusCode(error) {
+  return Number(error?.statusCode) || 500;
+}
+
+function errorBody(error) {
+  return {
+    error: error?.message || 'SkillHub 操作失败',
+    ...(error?.code ? { code: error.code } : {})
+  };
+}
+
+function registerSkillHubRoutes(app, {
+  settingsStore,
+  client,
+  installer,
+  sessionManager
+}) {
+  app.get('/api/skillhub/status', (_req, res) => {
+    res.json({ available: installer.available === true });
+  });
+
+  app.get('/api/skillhub/settings', (_req, res) => {
+    try { res.json(settingsStore.getPublic()); }
+    catch (error) { res.status(statusCode(error)).json(errorBody(error)); }
+  });
+
+  app.put('/api/skillhub/settings', async (req, res) => {
+    try {
+      const resolved = settingsStore.resolve(req.body || {});
+      const user = await client.test(resolved);
+      const settings = settingsStore.save(resolved);
+      res.json({ success: true, settings, user });
+    } catch (error) {
+      res.status(statusCode(error)).json(errorBody(error));
+    }
+  });
+
+  app.delete('/api/skillhub/settings', (_req, res) => {
+    try { res.json({ success: true, settings: settingsStore.clear() }); }
+    catch (error) { res.status(statusCode(error)).json(errorBody(error)); }
+  });
+
+  app.post('/api/skillhub/settings/test', async (req, res) => {
+    try {
+      const settings = settingsStore.resolve(req.body || {});
+      const user = await client.test(settings);
+      res.json({ success: true, user });
+    } catch (error) {
+      res.status(statusCode(error)).json(errorBody(error));
+    }
+  });
+
+  app.get('/api/skillhub/skills', async (_req, res) => {
+    try {
+      installer.assertAvailable();
+      const skills = await client.listSkills();
+      res.json({ success: true, skills });
+    } catch (error) {
+      res.status(statusCode(error)).json(errorBody(error));
+    }
+  });
+
+  app.post('/api/skillhub/sessions', async (req, res) => {
+    const sessionId = uuidv4();
+    let created = false;
+    try {
+      if (req.body?.toolKey !== 'codex') {
+        const error = new Error('SkillHub Session 当前只支持 Codex');
+        error.statusCode = 400;
+        error.code = 'SKILLHUB_CODEX_ONLY';
+        throw error;
+      }
+      const activeSkill = await installer.prepare(sessionId, req.body?.skill || {});
+      const session = sessionManager.create({
+        id: sessionId,
+        toolKey: 'codex',
+        workingDirectory: req.body?.workingDirectory,
+        name: activeSkill.name,
+        codexOptions: {
+          activeSkill,
+          extraSkillRoots: [activeSkill.skillsRoot]
+        },
+        disposeResources: () => installer.cleanupSync(sessionId)
+      });
+      created = true;
+      const defaultPrompt = activeSkill.defaultPrompt
+        || '请先用中文介绍这个 Skill 能完成什么、适合哪些任务，以及用户接下来应该如何使用。这一轮只做使用引导。';
+      const intro = `$${activeSkill.name}\n\n${defaultPrompt}`;
+      const started = await sessionManager.sendCodexInput(session.id, intro, [], [activeSkill], []);
+      if (!started) throw new Error('Codex Skill 引导会话启动失败');
+      res.status(201).json({ id: session.id, name: session.name });
+    } catch (error) {
+      if (created) await sessionManager.kill(sessionId).catch(() => {});
+      else {
+        try { installer.cleanupSync(sessionId); } catch (_) { /* 目录可能尚未创建 */ }
+      }
+      res.status(statusCode(error)).json(errorBody(error));
+    }
+  });
+}
+
+module.exports = registerSkillHubRoutes;

package/lib/session/session-manager.js

@@ -38,6 +38,12 @@ function promptWithFileReferences(text, attachments) {
   return prompt ? `${prompt}\n\n${note}` : note;
 }
 
+const STRUCTURED_SESSION_KINDS = new Set(['claude-structured', 'codex-structured']);
+
+function isStructuredSession(session) {
+  return Boolean(session && STRUCTURED_SESSION_KINDS.has(session.kind));
+}
+
 class SessionManager extends EventEmitter {
   constructor({ baseDir, renderHistoryTools, debugHistoryEnabled = false, logger, hasConnectedSessionClient, claudeTranscriptRepository, codexImageStore, fileAttachmentStore, claudeForkSession } = {}) {
     super();
@@ -77,7 +83,7 @@ class SessionManager extends EventEmitter {
       startTime: session.startTime,
       toolKey: session.tool.key,
       workingDirectory: this.getSessionWorkingDirectory(session),
-      mode: ['claude-structured', 'codex-structured'].includes(session.kind) ? 'structured' : 'terminal',
+      mode: isStructuredSession(session) ? 'structured' : 'terminal',
       hasUnreadCompletion: Boolean(session.hasUnreadCompletion),
       serverChanNotificationEnabled: Boolean(session.serverChanNotificationEnabled),
       timedInputCount: session.timedInputs
@@ -94,7 +100,7 @@ class SessionManager extends EventEmitter {
     return this.sessions.has(id);
   }
 
-  create({ toolKey, workingDirectory, name, claudeOptions }) {
+  create({ id: requestedId, toolKey, workingDirectory, name, claudeOptions, codexOptions, disposeResources }) {
     this.logger.info(`Creating session: toolKey=${toolKey || ''}, workingDirectory=${workingDirectory || '(default)'}`);
     const tool = getToolByKey(toolKey);
     if (!tool) {
@@ -108,7 +114,14 @@ class SessionManager extends EventEmitter {
       return this.createClaudeStructuredSession({ tool, workingDirectory, name, claudeOptions });
     }
     if (tool.key === 'codex') {
-      return this.createCodexStructuredSession({ tool, workingDirectory, name });
+      return this.createCodexStructuredSession({
+        id: requestedId,
+        tool,
+        workingDirectory,
+        name,
+        codexOptions,
+        disposeResources
+      });
     }
 
     const id = uuidv4();
@@ -210,7 +223,7 @@ class SessionManager extends EventEmitter {
     return session;
   }
 
-  createCodexStructuredSession({ tool, workingDirectory, name, codexOptions = {} }) {
+  createCodexStructuredSession({ id: requestedId, tool, workingDirectory, name, codexOptions = {}, disposeResources = null }) {
     const sessionDir = workingDirectory && String(workingDirectory).trim()
       ? path.resolve(this.baseDir, String(workingDirectory).trim())
       : this.baseDir;
@@ -219,12 +232,13 @@ class SessionManager extends EventEmitter {
       err.statusCode = 400;
       throw err;
     }
-    const id = uuidv4();
+    const id = requestedId || uuidv4();
     const session = new CodexStructuredSession({ id, tool, workingDir: sessionDir, name: name || tool.displayName, logger: this.logger, options: codexOptions });
     session.imageAttachments = new Map();
     session.imageUploads = new Map();
     session.fileAttachments = new Map();
     session.fileUploads = new Map();
+    session.disposeResources = typeof disposeResources === 'function' ? disposeResources : null;
     this.sessions.set(id, session);
     session.on('event', event => this.emit('codex-event', { sessionId: id, event, session }));
     session.on('exit', () => this.handleExit(session));
@@ -239,13 +253,13 @@ class SessionManager extends EventEmitter {
     const session = this.get(id);
     if (!session) return false;
     this.markSessionInput(session, data);
-    if (['claude-structured', 'codex-structured'].includes(session.kind)) return session.write(data);
+    if (isStructuredSession(session)) return session.write(data);
     return session.ptyManager.write(data);
   }
 
   sendTerminalFileInput(id, text, fileAttachmentIds = []) {
     const session = this.get(id);
-    if (!session || ['claude-structured', 'codex-structured'].includes(session.kind)) return false;
+    if (!session || isStructuredSession(session)) return false;
     const files = this.getFileAttachments(id, fileAttachmentIds);
     const prompt = promptWithFileReferences(text, files);
     if (!prompt) return false;
@@ -519,7 +533,7 @@ class SessionManager extends EventEmitter {
   redraw(id, cols, rows) {
     const session = this.get(id);
     if (!session) return false;
-    if (['claude-structured', 'codex-structured'].includes(session.kind)) return true;
+    if (isStructuredSession(session)) return true;
     if (session.renderedHistory) {
       session.renderedHistory.resize(cols, rows);
     }
@@ -537,7 +551,7 @@ class SessionManager extends EventEmitter {
   markCompletionRead(id) {
     const session = this.get(id);
     if (!session) return null;
-    if (['claude-structured', 'codex-structured'].includes(session.kind)) {
+    if (isStructuredSession(session)) {
       session.markCompletionRead();
       this.logSessionDiagnostics('completion-read', session, {}, { compact: true });
       return session;
@@ -661,33 +675,57 @@ class SessionManager extends EventEmitter {
     return true;
   }
 
-  async kill(id) {
-    const session = this.get(id);
-    if (!session) return false;
+  quiesceSession(session) {
     clearTimeout(session.completionTimer);
     this.clearTimedInputs(session);
+  }
+
+  disposeSessionResources(session) {
+    this.quiesceSession(session);
     this.clearCodexImageUploads(session);
     this.clearCodexImageAttachments(session);
-    this.logSessionDiagnostics('session-deleted', session, {}, { compact: true });
+    this.fileAttachmentStore.clear(session);
+    if (typeof session.disposeResources === 'function') {
+      try { session.disposeResources(); } catch (error) {
+        this.logger.error?.(`Failed to clean session resources ${session.id}: ${error.message}`);
+      }
+      session.disposeResources = null;
+    }
     this.disposeSessionHistory(session);
-    if (['claude-structured', 'codex-structured'].includes(session.kind)) {
-      await session.ptyManager.kill();
-      return true;
+  }
+
+  async stopSessionRuntime(session) {
+    if (isStructuredSession(session)) {
+      await session.kill();
+      return;
     }
     session.ptyManager.kill();
-    this.sessions.delete(id);
-    this.emit('exit', { sessionId: id, session });
+  }
+
+  removeSession(session) {
+    if (this.sessions.get(session.id) !== session) return false;
+    this.disposeSessionResources(session);
+    this.sessions.delete(session.id);
+    this.emit('exit', { sessionId: session.id, session });
+    return true;
+  }
+
+  async kill(id) {
+    const session = this.get(id);
+    if (!session) return false;
+    this.logSessionDiagnostics('session-deleted', session, {}, { compact: true });
+    this.quiesceSession(session);
+    await this.stopSessionRuntime(session);
+    this.removeSession(session);
     return true;
   }
 
   killAll() {
-    for (const session of this.sessions.values()) {
-      clearTimeout(session.completionTimer);
-      this.clearTimedInputs(session);
-      this.clearCodexImageUploads(session);
-      this.clearCodexImageAttachments(session);
-      this.disposeSessionHistory(session);
-      session.ptyManager.kill();
+    for (const session of Array.from(this.sessions.values())) {
+      this.disposeSessionResources(session);
+      void this.stopSessionRuntime(session).catch(error => {
+        this.logger.error?.(`Failed to stop session ${session.id}: ${error.message}`);
+      });
     }
     this.sessions.clear();
   }
@@ -695,7 +733,7 @@ class SessionManager extends EventEmitter {
   getHistory(id) {
     const session = this.get(id);
     if (!session) return null;
-    if (['claude-structured', 'codex-structured'].includes(session.kind)) return session.getHistory();
+    if (isStructuredSession(session)) return session.getHistory();
     const historySource = session.renderedHistory || session.textHistory;
     return {
       success: true,
@@ -710,7 +748,7 @@ class SessionManager extends EventEmitter {
   getCatchupOutput(id) {
     const session = this.get(id);
     if (!session) return null;
-    if (['claude-structured', 'codex-structured'].includes(session.kind)) return session.getCatchupOutput();
+    if (isStructuredSession(session)) return session.getCatchupOutput();
 
     const bufferHistory = session.buffer.getAfter(0);
     if (bufferHistory.length > 0) {
@@ -849,22 +887,15 @@ class SessionManager extends EventEmitter {
   }
 
   handleExit(session) {
-    if (!this.sessions.has(session.id)) return;
+    if (this.sessions.get(session.id) !== session) return;
     this.logger.info(`Session ${session.id} (${session.name}) exited.`);
-    clearTimeout(session.completionTimer);
-    this.clearTimedInputs(session);
-    this.clearCodexImageUploads(session);
-    this.clearCodexImageAttachments(session);
-    this.fileAttachmentStore.clear(session);
-    this.disposeSessionHistory(session);
-    this.sessions.delete(session.id);
-    this.emit('exit', { sessionId: session.id, session });
+    this.removeSession(session);
   }
 
   markSessionInput(session, data) {
     if (typeof data !== 'string' || data.length === 0) return;
     session.inputSeq = (session.inputSeq || 0) + 1;
-    if (['claude-structured', 'codex-structured'].includes(session.kind)) {
+    if (isStructuredSession(session)) {
       session.hasUnreadCompletion = false;
       this.logSessionDiagnostics('session-input', session, {
         inputSeq: session.inputSeq,
@@ -883,7 +914,7 @@ class SessionManager extends EventEmitter {
   }
 
   disposeSessionHistory(session) {
-    if (['claude-structured', 'codex-structured'].includes(session.kind)) return;
+    if (isStructuredSession(session)) return;
     if (session.renderedHistory) {
       session.renderedHistory.dispose();
       session.renderedHistory = null;
@@ -907,7 +938,7 @@ class SessionManager extends EventEmitter {
   }
 
   getSessionDiagnostics(session, extra = {}) {
-    if (['claude-structured', 'codex-structured'].includes(session.kind)) {
+    if (isStructuredSession(session)) {
       return {
         sessionId: session.id,
         sessionName: session.name,
@@ -936,7 +967,7 @@ class SessionManager extends EventEmitter {
   }
 
   getCompactSessionDiagnostics(session, extra = {}) {
-    if (['claude-structured', 'codex-structured'].includes(session.kind)) {
+    if (isStructuredSession(session)) {
       return this.getSessionDiagnostics(session, extra);
     }
     const buffer = session.buffer.getDebugSnapshot();

package/lib/skillhub/client.js

@@ -0,0 +1,121 @@
+const DEFAULT_TIMEOUT_MS = 15_000;
+const MAX_BUNDLE_BYTES = 20 * 1024 * 1024;
+
+function clientProblem(message, statusCode = 502, code = 'SKILLHUB_REQUEST_FAILED') {
+  const error = new Error(message);
+  error.statusCode = statusCode;
+  error.code = code;
+  return error;
+}
+
+class SkillHubClient {
+  constructor({ settingsStore, fetchImpl = global.fetch, timeoutMs = DEFAULT_TIMEOUT_MS } = {}) {
+    this.settingsStore = settingsStore;
+    this.fetchImpl = fetchImpl;
+    this.timeoutMs = timeoutMs;
+  }
+
+  async request(pathname, { method = 'GET', settings = null, body = null, accept = 'application/json' } = {}) {
+    const current = settings || this.settingsStore.resolve();
+    const base = `${current.baseUrl.replace(/\/$/, '')}/`;
+    const path = String(pathname || '').replace(/^\//, '');
+    const url = new URL(path, base);
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+    try {
+      const response = await this.fetchImpl(url, {
+        method,
+        redirect: 'error',
+        signal: controller.signal,
+        headers: {
+          Accept: accept,
+          Authorization: `Bearer ${current.token}`,
+          ...(body ? { 'Content-Type': 'application/json' } : {})
+        },
+        ...(body ? { body: JSON.stringify(body) } : {})
+      });
+      if (!response.ok) {
+        let detail = '';
+        try {
+          const payload = await response.json();
+          detail = payload?.error?.message || payload?.error || payload?.message || '';
+        } catch (_) { /* response body is not JSON */ }
+        const statusCode = response.status === 401 || response.status === 403 ? response.status : 502;
+        const code = response.status === 401 ? 'SKILLHUB_UNAUTHORIZED'
+          : response.status === 403 ? 'SKILLHUB_FORBIDDEN' : 'SKILLHUB_BAD_RESPONSE';
+        throw clientProblem(detail || `SkillHub 返回 HTTP ${response.status}`, statusCode, code);
+      }
+      return response;
+    } catch (error) {
+      if (error.statusCode) throw error;
+      if (error.name === 'AbortError') throw clientProblem('SkillHub 请求超时', 504, 'SKILLHUB_TIMEOUT');
+      throw clientProblem(`无法连接 SkillHub：${error.message}`);
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+
+  async test(settings) {
+    const response = await this.request('/api/v1/whoami', { settings });
+    return response.json();
+  }
+
+  async listSkills() {
+    const items = [];
+    let cursor = '';
+    for (let page = 0; page < 100; page += 1) {
+      const query = new URLSearchParams({ limit: '100', order: 'updated_at_desc' });
+      if (cursor) query.set('cursor', cursor);
+      const response = await this.request(`/api/runtime/skills?${query}`);
+      const payload = await response.json();
+      if (!Array.isArray(payload?.data)) throw clientProblem('SkillHub Skill 列表格式无效');
+      items.push(...payload.data);
+      cursor = String(payload.nextCursor || '');
+      if (!cursor) return items;
+    }
+    throw clientProblem('SkillHub Skill 列表分页过多');
+  }
+
+  async getSkill({ id, version, digest }) {
+    const query = new URLSearchParams({ include: 'manifest,skillMd' });
+    if (version) query.set('version', version);
+    if (digest) query.set('digest', digest);
+    const response = await this.request(`/api/runtime/skills/by-id/${encodeURIComponent(id)}?${query}`);
+    return response.json();
+  }
+
+  async downloadBundle({ id, version, digest }) {
+    const query = new URLSearchParams({ id, format: 'zip' });
+    if (version) query.set('version', version);
+    if (digest) query.set('digest', digest);
+    const response = await this.request(`/api/runtime/skills/bundle?${query}`, {
+      accept: 'application/zip'
+    });
+    const declared = Number(response.headers.get('content-length') || 0);
+    if (declared > MAX_BUNDLE_BYTES) {
+      throw clientProblem('Skill bundle 超过 20 MB', 413, 'SKILLHUB_BUNDLE_TOO_LARGE');
+    }
+    if (!response.body) throw clientProblem('SkillHub 返回了空 bundle');
+    const reader = response.body.getReader();
+    const chunks = [];
+    let total = 0;
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      total += value.byteLength;
+      if (total > MAX_BUNDLE_BYTES) {
+        await reader.cancel();
+        throw clientProblem('Skill bundle 超过 20 MB', 413, 'SKILLHUB_BUNDLE_TOO_LARGE');
+      }
+      chunks.push(Buffer.from(value));
+    }
+    const buffer = Buffer.concat(chunks, total);
+    return {
+      buffer,
+      digest: response.headers.get('x-saker-skill-digest') || '',
+      sha256: response.headers.get('x-saker-bundle-sha256') || ''
+    };
+  }
+}
+
+module.exports = { SkillHubClient, MAX_BUNDLE_BYTES };