skill-base 2.0.3 → 2.0.6

package/src/cappy.js

@@ -0,0 +1,416 @@
+const readline = require('readline');
+
+class CappyMascot {
+  constructor(port, basePath = '/') {
+    this.port = port;
+    this.basePath = basePath;
+    this.frameTimer = null;
+    this.sceneTimer = null;
+    this.lastRenderHeight = 0;
+    this.currentSceneKey = null;
+    this.isRunning = false;
+    this.isStopped = false;
+    this.cursorHidden = false;
+
+    this.colors = {
+      warm: '\x1b[38;5;221m',
+      orange: '\x1b[38;5;214m',
+      cyan: '\x1b[38;5;117m',
+      pink: '\x1b[38;5;218m',
+      soft: '\x1b[38;5;188m',
+      reset: '\x1b[0m'
+    };
+
+    // 数据很简单：scene 决定人格，frame 决定动作，message 决定台词。
+    this.scenes = {
+      intro: {
+        frameDelay: 240,
+        loops: 1,
+        messages: [
+          `Skill Base 正在热机，路径 ${basePath} 已准备好。`
+        ],
+        frames: [
+          { color: 'warm', sprite: this.createSprite('o o', '___', 'paw') },
+          { color: 'orange', sprite: this.createSprite('- -', '___', 'paw') },
+          { color: 'warm', sprite: this.createSprite('^ ^', '___', 'still') }
+        ]
+      },
+      idle: {
+        weight: 5,
+        frameDelay: 320,
+        loops: 4,
+        messages: [
+          `Cappy 正在看着 ${basePath} 路径发呆。`,
+          '一切正常。没有过度设计，就没有运行时焦虑。',
+          '技能仓库很安静，直白的代码才能带来这种安宁。',
+          '系统稳定。Cappy 鄙视无谓的复杂度。'
+        ],
+        frames: [
+          { color: 'warm', sprite: this.createSprite('o o', '___', 'still') },
+          { color: 'warm', sprite: this.createSprite('o o', '___', 'breath') },
+          { color: 'warm', sprite: this.createSprite('o o', '___', 'still') }
+        ]
+      },
+      blink: {
+        weight: 2,
+        frameDelay: 180,
+        loops: 2,
+        messages: [
+          '缓慢地眨了下眼。不是摸鱼，是在进行低成本巡检。',
+          '与其写一堆监控脚本，不如把代码写得简单点。'
+        ],
+        frames: [
+          { color: 'warm', sprite: this.createSprite('o o', '___', 'still') },
+          { color: 'warm', sprite: this.createSprite('- -', '___', 'still') },
+          { color: 'warm', sprite: this.createSprite('o o', '___', 'still') }
+        ]
+      },
+      think: {
+        weight: 1,
+        frameDelay: 280,
+        loops: 3,
+        messages: [
+          '简单的架构才是最好的。真正的稳定性是不需要花哨设计的。',
+          '思考中。直接写代码，比写那些自作聪明的抽象层靠谱多了。'
+        ],
+        frames: [
+          { color: 'cyan', sprite: this.createSprite('o o', '___', 'think-left') },
+          { color: 'cyan', sprite: this.createSprite('^ ^', '___', 'think-mid') },
+          { color: 'cyan', sprite: this.createSprite('o o', '___', 'think-right') }
+        ]
+      },
+      soak: {
+        weight: 1,
+        frameDelay: 340,
+        loops: 3,
+        messages: [
+          '数据结构对了，逻辑自然就像水一样顺畅。',
+          '泡一下就想明白了。别去猜未来的需求，YAGNI。'
+        ],
+        frames: [
+          { color: 'pink', sprite: this.createSprite('^ ^', '~~~', 'steam-left') },
+          { color: 'pink', sprite: this.createSprite('- -', '~~~', 'steam-mid') },
+          { color: 'pink', sprite: this.createSprite('^ ^', '~~~', 'steam-right') }
+        ]
+      },
+      scout: {
+        weight: 1,
+        frameDelay: 220,
+        loops: 4,
+        messages: [
+          '短距离散步。确认没有被哪个聪明人搞出过度设计。',
+          '没有多余步骤，只有必要移动。代码也该如此。'
+        ],
+        frames: [
+          { color: 'cyan', sprite: this.createSprite('o o', '___', 'step-left') },
+          { color: 'cyan', sprite: this.createSprite('o o', '___', 'step-mid') },
+          { color: 'cyan', sprite: this.createSprite('o o', '___', 'step-right') }
+        ]
+      },
+      work: {
+        frameDelay: 180,
+        loops: 6,
+        messages: [
+          '收到任务，Cappy 正在用最直接的方式处理。'
+        ],
+        frames: [
+          { color: 'cyan', sprite: this.createSprite('> <', '===', 'spark-left') },
+          { color: 'orange', sprite: this.createSprite('> <', '===', 'spark-right') }
+        ]
+      }
+    };
+
+    this.boundStop = this.stop.bind(this);
+  }
+
+  start() {
+    if (this.isRunning) return;
+
+    this.isRunning = true;
+    this.isStopped = false;
+    this.hideCursor();
+    process.once('SIGINT', this.boundStop);
+    process.once('SIGTERM', this.boundStop);
+
+    this.playScene('intro', {
+      onDone: () => this.scheduleNextIdle(600)
+    });
+  }
+
+  action(message) {
+    if (!this.isRunning || this.isStopped) return;
+
+    this.playScene('work', {
+      message: message || '有新动作发生了，但卡皮巴拉依然很稳。',
+      onDone: () => this.scheduleNextIdle(600)
+    });
+  }
+
+  stop() {
+    if (this.isStopped) return;
+
+    this.isStopped = true;
+    this.isRunning = false;
+    clearInterval(this.frameTimer);
+    clearTimeout(this.sceneTimer);
+
+    this.clearRender();
+    const goodbye = [
+      `${this.colors.soft}  ╭──────────────────────────────╮${this.colors.reset}`,
+      `${this.colors.soft}  │ Cappy 下班了，明天继续值守。 │${this.colors.reset}`,
+      `${this.colors.soft}  ╰──────────────┬───────────────╯${this.colors.reset}`,
+      `${this.colors.warm}                 \\${this.colors.reset}`,
+      `${this.colors.warm}                  __${this.colors.reset}`,
+      `${this.colors.warm}              ___( ; ;)___${this.colors.reset}`,
+      `${this.colors.warm}             /__         _\\${this.colors.reset}`,
+      `${this.colors.warm}                /_/\\_\\${this.colors.reset}`
+    ];
+
+    process.stdout.write(`${goodbye.join('\n')}\n`);
+    this.showCursor();
+    process.exit(0);
+  }
+
+  scheduleNextIdle(delay = this.randomBetween(1400, 2800)) {
+    clearTimeout(this.sceneTimer);
+    this.sceneTimer = setTimeout(() => {
+      const nextSceneKey = this.pickIdleScene();
+      this.playScene(nextSceneKey, {
+        onDone: () => this.scheduleNextIdle()
+      });
+    }, delay);
+  }
+
+  playScene(sceneKey, options = {}) {
+    const scene = this.scenes[sceneKey];
+    if (!scene || this.isStopped) return;
+
+    clearInterval(this.frameTimer);
+    clearTimeout(this.sceneTimer);
+
+    this.currentSceneKey = sceneKey;
+
+    const frames = scene.frames;
+    const frameDelay = scene.frameDelay || 240;
+    const totalLoops = options.loops || scene.loops || 1;
+    const message = options.message || this.pick(scene.messages);
+    let index = 0;
+    let remainingLoops = totalLoops;
+
+    const tick = () => {
+      const frame = frames[index];
+      this.render(frame, message);
+      index += 1;
+
+      if (index >= frames.length) {
+        index = 0;
+        remainingLoops -= 1;
+
+        if (remainingLoops <= 0) {
+          clearInterval(this.frameTimer);
+          this.frameTimer = null;
+
+          if (typeof options.onDone === 'function') {
+            options.onDone();
+          }
+        }
+      }
+    };
+
+    tick();
+    this.frameTimer = setInterval(tick, frameDelay);
+  }
+
+  render(frame, message) {
+    const lines = [
+      ...this.buildBubble(message),
+      ...frame.sprite.map((line) => `  ${this.colors[frame.color]}${line}${this.colors.reset}`),
+      `  ${this.colors.soft}http://localhost:${this.port}${this.basePath}  |  Cappy on duty${this.colors.reset}`
+    ];
+
+    this.clearRender();
+    process.stdout.write(lines.join('\n'));
+    this.lastRenderHeight = lines.length;
+  }
+
+  clearRender() {
+    if (!this.lastRenderHeight) return;
+
+    readline.cursorTo(process.stdout, 0);
+
+    for (let i = 0; i < this.lastRenderHeight; i += 1) {
+      readline.clearLine(process.stdout, 0);
+
+      if (i < this.lastRenderHeight - 1) {
+        readline.moveCursor(process.stdout, 0, -1);
+      }
+    }
+
+    readline.cursorTo(process.stdout, 0);
+    this.lastRenderHeight = 0;
+  }
+
+  buildBubble(message) {
+    const text = this.fit(message, 34);
+    const width = text.length;
+    const line = '─'.repeat(width + 2);
+
+    return [
+      `${this.colors.soft}  ╭${line}╮${this.colors.reset}`,
+      `${this.colors.soft}  │ ${text} │${this.colors.reset}`,
+      `${this.colors.soft}  ╰${line}╯${this.colors.reset}`,
+      `${this.colors.soft}         \\${this.colors.reset}`
+    ];
+  }
+
+  pickIdleScene() {
+    const entries = Object.entries(this.scenes)
+      .filter(([key, scene]) => scene.weight)
+      .filter(([key]) => key !== this.currentSceneKey);
+
+    const totalWeight = entries.reduce((sum, [, scene]) => sum + scene.weight, 0);
+    let cursor = Math.random() * totalWeight;
+
+    for (const [key, scene] of entries) {
+      cursor -= scene.weight;
+      if (cursor <= 0) return key;
+    }
+
+    return 'idle';
+  }
+
+  pick(list) {
+    return list[Math.floor(Math.random() * list.length)];
+  }
+
+  fit(text, width) {
+    if (text.length <= width) {
+      return text.padEnd(width, ' ');
+    }
+
+    return `${text.slice(0, width - 1)}…`;
+  }
+
+  randomBetween(min, max) {
+    return Math.floor(Math.random() * (max - min + 1)) + min;
+  }
+
+  hideCursor() {
+    if (this.cursorHidden) return;
+    process.stdout.write('\x1B[?25l');
+    this.cursorHidden = true;
+  }
+
+  showCursor() {
+    if (!this.cursorHidden) return;
+    process.stdout.write('\x1B[?25h');
+    this.cursorHidden = false;
+  }
+
+  createSprite(eyes, waterline, pose) {
+    const variants = {
+      still: [
+        '        __',
+        `   _____/  \\`,
+        ` _(  ${eyes}    )__`,
+        `/__         __\\`,
+        `   ${waterline} /_/  \\_\\`
+      ],
+      breath: [
+        '         __',
+        `   ______/  \\`,
+        ` _(  ${eyes}    )__`,
+        `/__         __\\`,
+        `   ${waterline}  /_/  \\_\\`
+      ],
+      paw: [
+        '        __',
+        `   _____/  \\`,
+        ` _(  ${eyes}    )__`,
+        `/__   __    __\\`,
+        `   ${waterline} /_/  \\_\\`
+      ],
+      'orange-left': [
+        '      🍊 __',
+        `   _____/  \\`,
+        ` _(  ${eyes}    )__`,
+        `/__         __\\`,
+        `   ${waterline} /_/  \\_\\`
+      ],
+      'orange-mid': [
+        '        __',
+        `   ___🍊_/  \\`,
+        ` _(  ${eyes}    )__`,
+        `/__         __\\`,
+        `   ${waterline} /_/  \\_\\`
+      ],
+      'orange-right': [
+        '        __ 🍊',
+        `   _____/  \\`,
+        ` _(  ${eyes}    )__`,
+        `/__         __\\`,
+        `   ${waterline} /_/  \\_\\`
+      ],
+      'steam-left': [
+        '   ♨️      ♨️',
+        `   _____/  \\`,
+        ` _(  ${eyes}    )__`,
+        `/__         __\\`,
+        `   ${waterline} /_/  \\_\\`
+      ],
+      'steam-mid': [
+        '    ♨️    ♨️',
+        `   _____/  \\`,
+        ` _(  ${eyes}    )__`,
+        `/__         __\\`,
+        `   ${waterline} /_/  \\_\\`
+      ],
+      'steam-right': [
+        '  ♨️        ♨️',
+        `   _____/  \\`,
+        ` _(  ${eyes}    )__`,
+        `/__         __\\`,
+        `   ${waterline} /_/  \\_\\`
+      ],
+      'step-left': [
+        '      __',
+        ` _____/  \\`,
+        `(_  ${eyes}    )__`,
+        ` /__        __\\`,
+        `   ${waterline} /_/ \\_\\`
+      ],
+      'step-mid': [
+        '        __',
+        `   _____/  \\`,
+        ` _(  ${eyes}    )__`,
+        `/__         __\\`,
+        `   ${waterline} /_/  \\_\\`
+      ],
+      'step-right': [
+        '          __',
+        `     _____/  \\`,
+        `   _(  ${eyes}    )__`,
+        `  /__         __\\`,
+        `     ${waterline} /_/  \\_\\`
+      ],
+      'spark-left': [
+        '      ⚡ __',
+        `   _____/  \\`,
+        ` _(  ${eyes}    )__`,
+        `/__   __    __\\`,
+        `   ${waterline} /_/  \\_\\`
+      ],
+      'spark-right': [
+        '        __ ⚡',
+        `   _____/  \\`,
+        ` _(  ${eyes}    )__`,
+        `/__    __   __\\`,
+        `   ${waterline} /_/  \\_\\`
+      ]
+    };
+
+    return variants[pose] || variants.still;
+  }
+}
+
+module.exports = CappyMascot;

package/src/database.js

@@ -85,12 +85,23 @@ CREATE TABLE IF NOT EXISTS skill_collaborators (
     UNIQUE(skill_id, user_id)
 );
 
+-- Session 表（可选，通过 SESSION_STORE=sqlite 启用）
+CREATE TABLE IF NOT EXISTS sessions (
+    session_id    TEXT PRIMARY KEY,
+    user_id       INTEGER NOT NULL,
+    created_at    DATETIME DEFAULT CURRENT_TIMESTAMP,
+    expires_at    DATETIME NOT NULL,
+    FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE
+);
+
 -- 索引
 CREATE INDEX IF NOT EXISTS idx_versions_skill_id ON skill_versions(skill_id);
 CREATE INDEX IF NOT EXISTS idx_cli_codes_user ON cli_auth_codes(user_id);
 CREATE INDEX IF NOT EXISTS idx_pat_tokens_user ON personal_access_tokens(user_id);
 CREATE INDEX IF NOT EXISTS idx_collaborators_skill ON skill_collaborators(skill_id);
 CREATE INDEX IF NOT EXISTS idx_collaborators_user ON skill_collaborators(user_id);
+CREATE INDEX IF NOT EXISTS idx_sessions_user ON sessions(user_id);
+CREATE INDEX IF NOT EXISTS idx_sessions_expires ON sessions(expires_at);
 `;
 
 // 执行建表语句

package/src/index.js

@@ -1,9 +1,33 @@
+const fs = require('fs');
 const path = require('path');
 const fastify = require('fastify')({
   logger: false,
   // 设置 body 大小限制为 100MB（支持大 zip 上传）
   bodyLimit: 100 * 1024 * 1024
 });
+const CappyMascot = require('./cappy');
+
+// 1. 规范化部署前缀 (APP_BASE_PATH)
+let APP_BASE_PATH = process.env.APP_BASE_PATH || '/';
+// 确保以 / 开头，以 / 结尾
+if (!APP_BASE_PATH.startsWith('/')) APP_BASE_PATH = '/' + APP_BASE_PATH;
+if (!APP_BASE_PATH.endsWith('/')) APP_BASE_PATH = APP_BASE_PATH + '/';
+// 将多个连续斜杠替换为单个
+APP_BASE_PATH = APP_BASE_PATH.replace(/\/+/g, '/');
+
+const STATIC_ROOT = path.join(__dirname, '../static');
+const INDEX_HTML_PATH = path.join(STATIC_ROOT, 'index.html');
+
+function renderSpaHtml() {
+  const html = fs.readFileSync(INDEX_HTML_PATH, 'utf8');
+  const baseTag = `    <base href="${APP_BASE_PATH}">`;
+
+  if (html.includes('<base href=')) {
+    return html.replace(/<base href="[^"]*">/, baseTag.trim());
+  }
+
+  return html.replace('<head>', `<head>\n${baseTag}`);
+}
 
 // 主启动函数
 async function start() {
@@ -25,10 +49,25 @@ async function start() {
       }
     });
 
+    // 必须在 static 之前：index:false 时「目录 + 尾斜杠」会走 send 的 403，不会落到 notFoundHandler
+    fastify.route({
+      method: ['GET', 'HEAD'],
+      url: APP_BASE_PATH,
+      async handler(request, reply) {
+        reply.type('text/html; charset=utf-8');
+        if (request.method === 'HEAD') {
+          return reply.send();
+        }
+        return reply.send(renderSpaHtml());
+      }
+    });
+
     // @fastify/static — 静态文件服务（指向 static/ 目录）
     await fastify.register(require('@fastify/static'), {
-      root: path.join(__dirname, '../static'),
-      prefix: '/'
+      root: STATIC_ROOT,
+      prefix: APP_BASE_PATH,
+      wildcard: true,
+      index: false
     });
 
     // 2. 注册自定义中间件
@@ -39,35 +78,34 @@ async function start() {
     // 管理员权限（注册 requireAdmin 装饰器）
     await fastify.register(require('./middleware/admin'));
 
-    // 3. 注册 API 路由（前缀 /api/v1）
-    await fastify.register(require('./routes/init'), { prefix: '/api/v1/init' });
-    await fastify.register(require('./routes/auth'), { prefix: '/api/v1/auth' });
-    await fastify.register(require('./routes/skills'), { prefix: '/api/v1/skills' });
-    await fastify.register(require('./routes/publish'), { prefix: '/api/v1/skills' });
-    await fastify.register(require('./routes/collaborators'), { prefix: '/api/v1/skills' });
-    await fastify.register(require('./routes/users'), { prefix: '/api/v1/users' });
+    // 3. 注册 API 路由
+    const API_PREFIX = (APP_BASE_PATH + 'api/v1').replace(/\/+/g, '/');
+    await fastify.register(require('./routes/init'), { prefix: `${API_PREFIX}/init` });
+    await fastify.register(require('./routes/auth'), { prefix: `${API_PREFIX}/auth` });
+    await fastify.register(require('./routes/skills'), { prefix: `${API_PREFIX}/skills` });
+    await fastify.register(require('./routes/publish'), { prefix: `${API_PREFIX}/skills` });
+    await fastify.register(require('./routes/collaborators'), { prefix: `${API_PREFIX}/skills` });
+    await fastify.register(require('./routes/users'), { prefix: `${API_PREFIX}/users` });
 
     // 4. 页面路由 fallback（SPA 风格路由支持）
     fastify.setNotFoundHandler(async (request, reply) => {
+      const requestPath = request.url.split('?')[0];
+
       // API 路由返回 JSON 404
-      if (request.url.startsWith('/api/')) {
+      if (requestPath.startsWith(API_PREFIX)) {
         return reply.code(404).send({ detail: 'Not found' });
       }
 
-      // 页面路由映射到对应 HTML 文件
-      const url = request.url.split('?')[0]; // 去掉 query string
-
-      if (url === '/setup') return reply.sendFile('setup.html');
-      if (url === '/login') return reply.sendFile('login.html');
-      if (url === '/publish') return reply.sendFile('publish.html');
-      if (url === '/cli-code') return reply.sendFile('cli-code.html');
-      if (url === '/admin/users') return reply.sendFile('admin/users.html');
-      if (url.match(/^\/skill\/[^/]+\/file\//)) return reply.sendFile('file.html');
-      if (url.match(/^\/skill\/[^/]+\/diff/)) return reply.sendFile('diff.html');
-      if (url.match(/^\/skill\/[^/]+$/)) return reply.sendFile('skill.html');
+      // 已知静态资源缺失时直接返回 404，别把 HTML 假装成 JS/CSS
+      if (
+        requestPath.startsWith(`${APP_BASE_PATH}assets/`) ||
+        requestPath === `${APP_BASE_PATH}favicon.ico`
+      ) {
+        return reply.code(404).send({ detail: 'Not found' });
+      }
 
-      // 其他未匹配路由返回首页
-      return reply.sendFile('index.html');
+      // 所有非 API 请求回退到入口 HTML，由前端 Vue Router 处理
+      return reply.type('text/html; charset=utf-8').send(renderSpaHtml());
     });
 
     // 5. 确保数据库已初始化
@@ -76,9 +114,34 @@ async function start() {
     // 6. 启动服务
     const PORT = process.env.PORT || 8000;
     const HOST = process.env.HOST || '0.0.0.0';
+    
+    // 初始化 Cappy 水豚（必须在 listen 之前注册装饰器）
+    const cappy = new CappyMascot(PORT);
+    fastify.decorate('cappy', cappy);
+
+    // 优雅解耦：通过 Fastify 的全局生命周期钩子来驱动 Cappy 动画，完全不污染业务路由
+    fastify.addHook('onResponse', (request, reply, done) => {
+      // 只有成功请求才触发，不理会报错
+      if (reply.statusCode >= 200 && reply.statusCode < 300) {
+        const method = request.method;
+        const url = request.url.split('?')[0];
+
+        if (method === 'POST' && url === `${API_PREFIX}/users`) {
+          cappy.action('新用户被添加了。又多了一个打工人，系统依旧稳定。');
+        } else if (method === 'POST' && url === `${API_PREFIX}/skills/publish`) {
+          cappy.action('有新的 Skill/版本 发布了。希望它的代码没有过度设计。');
+        } else if (method === 'GET' && url.match(new RegExp(`^${API_PREFIX}/skills/[^/]+/versions/[^/]+/download/?$`))) {
+          cappy.action('有人拉取了 Skill。代码开始流通，Cappy 觉得很赞。');
+        }
+      }
+      done();
+    });
 
     await fastify.listen({ port: PORT, host: HOST });
-    console.log(`Skill Base server running at http://${HOST}:${PORT}`);
+    console.log(`\n📦 Skill Base Engine Initialized.\n`);
+    
+    // 启动 Cappy 守护进程
+    cappy.start();
   } catch (err) {
     console.error(err);
     process.exit(1);