kiku-agent 1.0.5 → 1.0.6

package/server/agent/updateManager.js

@@ -0,0 +1,438 @@
+import { spawn } from 'node:child_process';
+import { existsSync, promises as fs } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { KIKU_DATA_DIR } from './appPaths.js';
+import { PACKAGE_NAME, PACKAGE_VERSION } from './version.js';
+
+export const UPDATE_CHANNELS = Object.freeze(['latest', 'next', 'canary']);
+export const UPDATE_STATE_FILE = path.join(KIKU_DATA_DIR, 'update-state.json');
+
+const PACKAGE_ROOT = fileURLToPath(new URL('../../', import.meta.url));
+const STRICT_SEMVER = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/;
+const MAX_NPM_OUTPUT = 2 * 1024 * 1024;
+const DEFAULT_TIMEOUT_MS = 20_000;
+const INSTALL_TIMEOUT_MS = 180_000;
+
+export class UpdateError extends Error {
+  constructor(message, code = 'UPDATE_ERROR', details = {}) {
+    super(message);
+    this.name = 'UpdateError';
+    this.code = code;
+    this.details = details;
+  }
+}
+
+function cleanOutput(value, maxLength = 400) {
+  return String(value || '')
+    .replace(/\x1b(?:\[[0-?]*[ -/]*[@-~]|\][^\x07]*(?:\x07|\x1b\\))/g, '')
+    .replace(/[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/g, '')
+    .trim()
+    .slice(0, maxLength);
+}
+
+function parseSemver(value) {
+  const normalized = String(value || '').trim().replace(/^v/, '');
+  const match = normalized.match(STRICT_SEMVER);
+  if (!match) return null;
+  return {
+    raw: normalized,
+    major: Number(match[1]),
+    minor: Number(match[2]),
+    patch: Number(match[3]),
+    prerelease: match[4] ? match[4].split('.') : [],
+  };
+}
+
+function compareIdentifiers(left, right) {
+  const leftNumeric = /^\d+$/.test(left);
+  const rightNumeric = /^\d+$/.test(right);
+  if (leftNumeric && rightNumeric) return Number(left) - Number(right);
+  if (leftNumeric !== rightNumeric) return leftNumeric ? -1 : 1;
+  return left.localeCompare(right);
+}
+
+export function compareVersions(left, right) {
+  const a = parseSemver(left);
+  const b = parseSemver(right);
+  if (!a || !b) throw new UpdateError('The registry returned an invalid semantic version.', 'INVALID_SEMVER');
+  for (const key of ['major', 'minor', 'patch']) {
+    if (a[key] !== b[key]) return Math.sign(a[key] - b[key]);
+  }
+  if (a.prerelease.length === 0 && b.prerelease.length === 0) return 0;
+  if (a.prerelease.length === 0) return 1;
+  if (b.prerelease.length === 0) return -1;
+  const max = Math.max(a.prerelease.length, b.prerelease.length);
+  for (let index = 0; index < max; index++) {
+    if (a.prerelease[index] === undefined) return -1;
+    if (b.prerelease[index] === undefined) return 1;
+    const compared = compareIdentifiers(a.prerelease[index], b.prerelease[index]);
+    if (compared !== 0) return Math.sign(compared);
+  }
+  return 0;
+}
+
+export function isValidUpdateTarget(value) {
+  const normalized = String(value || '').trim().toLowerCase();
+  return UPDATE_CHANNELS.includes(normalized) || Boolean(parseSemver(normalized));
+}
+
+export function normalizeUpdateTarget(value, fallback = 'latest') {
+  const normalized = String(value || fallback).trim().toLowerCase().replace(/^v(?=\d)/, '');
+  if (!isValidUpdateTarget(normalized)) {
+    throw new UpdateError(
+      'Invalid update target. Use latest, next, canary, or an exact version such as 1.2.3.',
+      'INVALID_TARGET'
+    );
+  }
+  return normalized;
+}
+
+function satisfiesComparator(version, comparator) {
+  const match = comparator.match(/^(>=|<=|>|<|=|\^|~)?\s*(v?\d+(?:\.\d+){0,2})(?:\.x)?$/i);
+  if (!match) return false;
+  const operator = match[1] || '=';
+  const numericParts = match[2].replace(/^v/, '').split('.').map(Number);
+  while (numericParts.length < 3) numericParts.push(0);
+  const target = numericParts.join('.');
+  const compared = compareVersions(version, target);
+  if (operator === '>=') return compared >= 0;
+  if (operator === '<=') return compared <= 0;
+  if (operator === '>') return compared > 0;
+  if (operator === '<') return compared < 0;
+  if (operator === '~') {
+    const parsed = parseSemver(version);
+    return compared >= 0 && parsed.major === numericParts[0] && parsed.minor === numericParts[1];
+  }
+  if (operator === '^') {
+    const parsed = parseSemver(version);
+    if (numericParts[0] > 0) return compared >= 0 && parsed.major === numericParts[0];
+    if (numericParts[1] > 0) return compared >= 0 && parsed.major === 0 && parsed.minor === numericParts[1];
+    return compared >= 0 && parsed.major === 0 && parsed.minor === 0 && parsed.patch === numericParts[2];
+  }
+  return compared === 0;
+}
+
+export function satisfiesNodeEngine(nodeVersion, range) {
+  if (!range || range === '*') return true;
+  const version = String(nodeVersion || '').replace(/^v/, '').split('-')[0];
+  if (!parseSemver(version)) return false;
+  return String(range).split('||').some(alternative => {
+    const comparators = alternative.trim().split(/\s+/).filter(Boolean);
+    return comparators.length > 0 && comparators.every(comparator => satisfiesComparator(version, comparator));
+  });
+}
+
+function defaultNpmInvocation() {
+  const nodeDir = path.dirname(process.execPath);
+  const candidates = [
+    path.join(nodeDir, 'node_modules', 'npm', 'bin', 'npm-cli.js'),
+    path.resolve(nodeDir, '..', 'lib', 'node_modules', 'npm', 'bin', 'npm-cli.js'),
+    process.env.npm_execpath,
+  ].filter(Boolean);
+  const npmCli = candidates.find(candidate => /npm-cli\.(?:c?js|mjs)$/i.test(candidate) && existsSync(candidate));
+  if (npmCli) return { command: process.execPath, prefixArgs: [npmCli] };
+  return { command: process.platform === 'win32' ? 'npm.cmd' : 'npm', prefixArgs: [] };
+}
+
+export function runNpm(args, options = {}) {
+  if (!Array.isArray(args) || args.some(arg => typeof arg !== 'string')) {
+    return Promise.reject(new UpdateError('Invalid npm arguments.', 'INVALID_NPM_ARGS'));
+  }
+  const timeoutMs = options.timeoutMs || DEFAULT_TIMEOUT_MS;
+  const invocation = options.invocation || defaultNpmInvocation();
+  return new Promise((resolve, reject) => {
+    let stdout = '';
+    let stderr = '';
+    let settled = false;
+    const child = spawn(invocation.command, [...invocation.prefixArgs, ...args], {
+      shell: false,
+      windowsHide: true,
+      stdio: ['ignore', 'pipe', 'pipe'],
+      env: { ...process.env, NO_COLOR: '1', FORCE_COLOR: '0' },
+    });
+    const finish = (error, result) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      if (error) reject(error);
+      else resolve(result);
+    };
+    const append = (stream, chunk) => {
+      const next = stream + chunk.toString('utf8');
+      if (next.length > MAX_NPM_OUTPUT) {
+        try { child.kill('SIGKILL'); } catch {}
+        finish(new UpdateError('npm returned more data than expected.', 'NPM_OUTPUT_LIMIT'));
+        return stream;
+      }
+      return next;
+    };
+    child.stdout.on('data', chunk => { stdout = append(stdout, chunk); });
+    child.stderr.on('data', chunk => {
+      stderr = append(stderr, chunk);
+      if (typeof options.onStderr === 'function') options.onStderr(cleanOutput(chunk, 1000));
+    });
+    child.once('error', error => finish(new UpdateError(
+      `Unable to run npm: ${cleanOutput(error.message)}`,
+      'NPM_UNAVAILABLE',
+      { cause: error.code }
+    )));
+    child.once('close', code => finish(null, { code, stdout: stdout.trim(), stderr: stderr.trim() }));
+    const timer = setTimeout(() => {
+      try { child.kill('SIGKILL'); } catch {}
+      finish(new UpdateError('npm did not respond before the timeout.', 'NPM_TIMEOUT'));
+    }, timeoutMs);
+  });
+}
+
+function safeJsonParse(raw, code) {
+  try {
+    return JSON.parse(raw);
+  } catch {
+    throw new UpdateError('npm returned an unreadable response.', code);
+  }
+}
+
+function isPathInside(candidate, parent) {
+  const relative = path.relative(path.resolve(parent), path.resolve(candidate));
+  return relative === '' || (!relative.startsWith('..') && !path.isAbsolute(relative));
+}
+
+function normalizeState(raw = {}) {
+  const channel = UPDATE_CHANNELS.includes(raw.channel) ? raw.channel : 'latest';
+  const installs = Array.isArray(raw.installs)
+    ? raw.installs.filter(item => parseSemver(item?.from) && parseSemver(item?.to)).slice(-20)
+    : [];
+  return { schemaVersion: 1, channel, installs, lastCheck: raw.lastCheck || null };
+}
+
+export class UpdateManager {
+  constructor(options = {}) {
+    this.packageName = options.packageName || PACKAGE_NAME;
+    this.currentVersion = options.currentVersion || PACKAGE_VERSION;
+    this.packageRoot = options.packageRoot || PACKAGE_ROOT;
+    this.stateFile = options.stateFile || UPDATE_STATE_FILE;
+    this.nodeVersion = options.nodeVersion || process.versions.node;
+    this.env = options.env || process.env;
+    this.runner = options.runner || ((args, runnerOptions) => runNpm(args, runnerOptions));
+  }
+
+  async readState() {
+    try {
+      return normalizeState(JSON.parse(await fs.readFile(this.stateFile, 'utf8')));
+    } catch (error) {
+      if (error.code === 'ENOENT' || error instanceof SyntaxError) return normalizeState();
+      throw new UpdateError('Unable to read update settings.', 'STATE_READ_FAILED', { cause: error.code });
+    }
+  }
+
+  async writeState(state) {
+    const normalized = normalizeState(state);
+    const directory = path.dirname(this.stateFile);
+    const temporary = path.join(directory, `.update-state-${process.pid}-${Date.now()}.tmp`);
+    try {
+      await fs.mkdir(directory, { recursive: true, mode: 0o700 });
+      await fs.writeFile(temporary, JSON.stringify(normalized, null, 2), { encoding: 'utf8', mode: 0o600 });
+      await fs.rename(temporary, this.stateFile);
+    } catch (error) {
+      try { await fs.unlink(temporary); } catch {}
+      throw new UpdateError('Unable to save update settings.', 'STATE_WRITE_FAILED', { cause: error.code });
+    }
+    return normalized;
+  }
+
+  async getChannel() {
+    return (await this.readState()).channel;
+  }
+
+  async setChannel(channel) {
+    const normalized = normalizeUpdateTarget(channel);
+    if (!UPDATE_CHANNELS.includes(normalized)) {
+      throw new UpdateError('Update channels are latest, next, or canary.', 'INVALID_CHANNEL');
+    }
+    const state = await this.readState();
+    state.channel = normalized;
+    await this.writeState(state);
+    return normalized;
+  }
+
+  async detectInstallMode() {
+    const normalizedRoot = path.resolve(this.packageRoot);
+    if (/[\\/]_npx[\\/]/i.test(normalizedRoot) || this.env.npm_command === 'exec') {
+      return { id: 'npx', label: 'npx / npm exec', automatic: false };
+    }
+    if (existsSync(path.join(normalizedRoot, '.git'))) {
+      return { id: 'source', label: 'Source checkout', automatic: false };
+    }
+    try {
+      const result = await this.runner(['root', '--global'], { timeoutMs: 5_000 });
+      if (result.code === 0 && result.stdout && isPathInside(normalizedRoot, result.stdout.trim())) {
+        return { id: 'global', label: 'Global npm', automatic: true };
+      }
+    } catch {}
+    if (/[\\/]node_modules[\\/]/i.test(normalizedRoot)) {
+      return { id: 'local', label: 'Local project dependency', automatic: false };
+    }
+    return { id: 'unknown', label: 'Unknown/manual installation', automatic: false };
+  }
+
+  async fetchRelease(target) {
+    const normalizedTarget = normalizeUpdateTarget(target);
+    const spec = `${this.packageName}@${normalizedTarget}`;
+    const result = await this.runner(['view', spec, '--json', '--prefer-online'], { timeoutMs: DEFAULT_TIMEOUT_MS });
+    if (result.code !== 0) {
+      throw new UpdateError(
+        cleanOutput(result.stderr) || 'npm could not find the requested release.',
+        'REGISTRY_LOOKUP_FAILED',
+        { exitCode: result.code }
+      );
+    }
+    const manifest = safeJsonParse(result.stdout, 'REGISTRY_RESPONSE_INVALID');
+    if (manifest.name !== this.packageName || !parseSemver(manifest.version)) {
+      throw new UpdateError('The registry response did not match kiku-agent.', 'REGISTRY_IDENTITY_MISMATCH');
+    }
+    if (parseSemver(normalizedTarget) && compareVersions(manifest.version, normalizedTarget) !== 0) {
+      throw new UpdateError('The registry resolved a different version than requested.', 'REGISTRY_VERSION_MISMATCH');
+    }
+    const metadata = manifest.kikuUpdate && typeof manifest.kikuUpdate === 'object' ? manifest.kikuUpdate : {};
+    const rawNotes = metadata.releaseSummary || metadata.releaseNotes || [];
+    const releaseNotes = (Array.isArray(rawNotes) ? rawNotes : [rawNotes])
+      .map(note => cleanOutput(note, 240))
+      .filter(Boolean)
+      .slice(0, 10);
+    return {
+      target: normalizedTarget,
+      version: manifest.version,
+      engines: manifest.engines || {},
+      deprecated: cleanOutput(manifest.deprecated, 300) || null,
+      integrity: cleanOutput(manifest.dist?.integrity, 300) || null,
+      releaseNotes,
+      releaseUrl: /^https:\/\//i.test(metadata.releaseUrl || '') ? cleanOutput(metadata.releaseUrl, 500) : null,
+    };
+  }
+
+  async check(target) {
+    const state = await this.readState();
+    const requestedTarget = normalizeUpdateTarget(target, state.channel);
+    const [release, installMode] = await Promise.all([
+      this.fetchRelease(requestedTarget),
+      this.detectInstallMode(),
+    ]);
+    const comparison = compareVersions(release.version, this.currentVersion);
+    const nodeRange = release.engines?.node || null;
+    const nodeCompatible = satisfiesNodeEngine(this.nodeVersion, nodeRange);
+    const current = parseSemver(this.currentVersion);
+    const next = parseSemver(release.version);
+    const status = {
+      packageName: this.packageName,
+      currentVersion: this.currentVersion,
+      targetVersion: release.version,
+      target: requestedTarget,
+      channel: UPDATE_CHANNELS.includes(requestedTarget) ? requestedTarget : state.channel,
+      comparison,
+      change: comparison > 0 ? 'upgrade' : comparison < 0 ? 'downgrade' : 'current',
+      updateAvailable: comparison > 0,
+      majorChange: current.major !== next.major,
+      nodeRange,
+      nodeCompatible,
+      installMode,
+      deprecated: release.deprecated,
+      integrity: release.integrity,
+      releaseNotes: release.releaseNotes,
+      releaseUrl: release.releaseUrl,
+    };
+    state.lastCheck = {
+      checkedAt: new Date().toISOString(),
+      currentVersion: status.currentVersion,
+      targetVersion: status.targetVersion,
+      target: status.target,
+    };
+    try { await this.writeState(state); } catch {}
+    return status;
+  }
+
+  manualCommand(installMode, version) {
+    if (installMode.id === 'npx') return `npx --yes --prefer-online ${this.packageName}@${version}`;
+    if (installMode.id === 'local') return `npm install ${this.packageName}@${version}`;
+    if (installMode.id === 'source') return 'git pull && npm install';
+    return `npm install --global ${this.packageName}@${version}`;
+  }
+
+  async install(target, options = {}) {
+    const status = await this.check(target);
+    if (status.deprecated && !options.allowDeprecated) {
+      throw new UpdateError(`This release is deprecated: ${status.deprecated}`, 'DEPRECATED_RELEASE');
+    }
+    if (!status.nodeCompatible) {
+      throw new UpdateError(
+        `Node ${this.nodeVersion} does not satisfy ${status.nodeRange}.`,
+        'NODE_INCOMPATIBLE'
+      );
+    }
+    if (status.majorChange && status.change === 'upgrade' && !options.allowMajor) {
+      throw new UpdateError(
+        `Version ${status.targetVersion} is a major update. Re-run with --allow-major after reviewing its release notes.`,
+        'MAJOR_CONFIRMATION_REQUIRED'
+      );
+    }
+    if (status.change === 'current') return { ...status, outcome: 'current' };
+    if (!status.installMode.automatic) {
+      return {
+        ...status,
+        outcome: 'manual',
+        command: this.manualCommand(status.installMode, status.targetVersion),
+      };
+    }
+
+    const exactSpec = `${this.packageName}@${status.targetVersion}`;
+    const result = await this.runner(
+      ['install', '--global', exactSpec, '--no-audit', '--no-fund'],
+      { timeoutMs: INSTALL_TIMEOUT_MS, onStderr: options.onProgress }
+    );
+    if (result.code !== 0) {
+      throw new UpdateError(
+        cleanOutput(result.stderr) || 'npm failed to install the update.',
+        'INSTALL_FAILED',
+        { exitCode: result.code, version: status.targetVersion }
+      );
+    }
+
+    const verification = await this.runner(
+      ['list', '--global', this.packageName, '--depth=0', '--json'],
+      { timeoutMs: DEFAULT_TIMEOUT_MS }
+    );
+    if (verification.code !== 0) {
+      throw new UpdateError('The update installed, but its version could not be verified.', 'VERIFY_FAILED');
+    }
+    const installed = safeJsonParse(verification.stdout, 'VERIFY_RESPONSE_INVALID')
+      ?.dependencies?.[this.packageName]?.version;
+    if (installed !== status.targetVersion) {
+      throw new UpdateError('npm reported a different installed version after updating.', 'VERIFY_VERSION_MISMATCH', {
+        expected: status.targetVersion,
+        installed,
+      });
+    }
+
+    let historyRecorded = true;
+    try {
+      const state = await this.readState();
+      state.installs.push({
+        from: this.currentVersion,
+        to: status.targetVersion,
+        target: status.target,
+        installedAt: new Date().toISOString(),
+      });
+      await this.writeState(state);
+    } catch {
+      historyRecorded = false;
+    }
+    return { ...status, outcome: 'installed', installedVersion: installed, historyRecorded };
+  }
+
+  async rollback(options = {}) {
+    const state = await this.readState();
+    const last = [...state.installs].reverse().find(item => item.to === this.currentVersion) || state.installs.at(-1);
+    if (!last) throw new UpdateError('No previous Kiku Agent version is recorded.', 'NO_ROLLBACK_VERSION');
+    return this.install(last.from, { ...options, allowMajor: true, rollback: true });
+  }
+}

package/server/agent/version.js

@@ -0,0 +1,10 @@
+import { readFileSync } from 'node:fs';
+
+const packageManifest = JSON.parse(
+  readFileSync(new URL('../../package.json', import.meta.url), 'utf8')
+);
+
+export const PACKAGE_NAME = packageManifest.name;
+export const PACKAGE_VERSION = packageManifest.version;
+export const PACKAGE_ENGINES = Object.freeze({ ...(packageManifest.engines || {}) });
+export const PACKAGE_UPDATE_METADATA = Object.freeze({ ...(packageManifest.kikuUpdate || {}) });

package/server/mcp/data/brands.js

@@ -1,9 +1,14 @@
 export const brandsData = [
   { id: "prsr", year: 2026, brandNameEn: "PRSR / Pasha", brandNameCn: "帕莎眼镜", title: "Global Brand Ambassador", category: "Luxury Eyewear", isGlobal: true, highlight: "Milan Fashion Week 2026 debut, viral pink sequin look" },
-  { id: "fred", year: 2026, brandNameEn: "FRED Jewelry", brandNameCn: "FRED珠宝", title: "Brand Ambassador", category: "Luxury Jewelry", isGlobal: false, highlight: "Force 10 High Jewelry editorial for PORT Magazine" },
-  { id: "tutucare", year: 2025, brandNameEn: "TuTuCare", brandNameCn: "凸凸棉", title: "Brand Ambassador", category: "Baby Care", isGlobal: false, highlight: "20,000 gift boxes sold out in 1 second, GMV 10.3M CNY in 1 hour" },
-  { id: "dafuyan", year: 2025, brandNameEn: "DAFUYAN", brandNameCn: "达肤妍", title: "Brand Ambassador", category: "Skincare", isGlobal: false, highlight: "10,000 sets sold out in 8 minutes, 20M CNY in 24 hours" },
-  { id: "lafang", year: 2025, brandNameEn: "Lafang", brandNameCn: "拉芳", title: "Global Brand Ambassador", category: "Hair Care", isGlobal: true, highlight: "First Global Ambassador in brand's 30-year history" },
+  { id: "versace", year: 2025, brandNameEn: "Versace Fragrance", brandNameCn: "范思哲香氛", title: "Global Fragrance Ambassador", category: "Luxury Fragrance", isGlobal: true, highlight: "Global ambassador for Versace Dylan Purple & luxury fragrance line" },
+  { id: "fred", year: 2025, brandNameEn: "FRED Jewelry", brandNameCn: "FRED珠宝 (LVMH)", title: "China Brand Ambassador", category: "Luxury Jewelry", isGlobal: false, highlight: "Force 10 High Jewelry editorial for PORT Magazine" },
+  { id: "tutucare", year: 2026, brandNameEn: "TuTuCare", brandNameCn: "凸凸棉", title: "Global Brand Ambassador", category: "Personal Care", isGlobal: true, highlight: "20,000 gift boxes sold out in 1 second, GMV 10.3M CNY in 1 hour" },
+  { id: "dafuyan", year: 2026, brandNameEn: "DAFUYAN", brandNameCn: "达肤妍", title: "Global Brand Ambassador", category: "Skincare", isGlobal: true, highlight: "10,000 sets sold out in 8 minutes, 20M CNY in 24 hours" },
+  { id: "lafang", year: 2026, brandNameEn: "Lafang", brandNameCn: "拉芳", title: "Global Brand Ambassador", category: "Hair Care", isGlobal: true, highlight: "First Global Ambassador in brand's 30-year history" },
+  { id: "makeup-forever", year: 2024, brandNameEn: "MAKE UP FOR EVER", brandNameCn: "玫珂菲 (LVMH)", title: "Brand Ambassador", category: "Professional Makeup", isGlobal: false, highlight: "Asia-Pacific brand ambassador for LVMH professional beauty" },
+  { id: "mistine", year: 2024, brandNameEn: "Mistine", brandNameCn: "蜜丝婷", title: "Global Sunscreen & Beauty Ambassador", category: "Sunscreen & Cosmetics", isGlobal: true, highlight: "Global ambassador for top-selling sunscreen and beauty products" },
+  { id: "maybelline", year: 2023, brandNameEn: "Maybelline New York", brandNameCn: "美宝莲纽约", title: "Brand Ambassador", category: "Makeup", isGlobal: false, highlight: "Campaign ambassador for viral lip and foundation lines" },
+  { id: "ysl", year: 2023, brandNameEn: "YSL Beauty", brandNameCn: "圣罗兰美妆", title: "Brand Friend", category: "Luxury Beauty", isGlobal: false, highlight: "Iconic campaign partnership for Libre fragrance and beauty" },
   { id: "oppo", year: 2024, brandNameEn: "OPPO", brandNameCn: "OPPO", title: "Brand Ambassador", category: "Technology", isGlobal: false, highlight: "Smartphone campaign across Asia" },
   { id: "loreal", year: 2024, brandNameEn: "L'Oréal Paris", brandNameCn: "巴黎欧莱雅", title: "Brand Ambassador", category: "Beauty", isGlobal: true, highlight: "Global beauty ambassador for L'Oréal Paris" },
 ];

package/server/mcp/server.js

@@ -1,4 +1,5 @@
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { PACKAGE_VERSION } from '../agent/version.js';
 import { z } from 'zod';
 import { toolDefinitions, handleToolCall } from './tools.js';
 import { resourceDefinitions, readResource } from './resources.js';
@@ -8,7 +9,7 @@ export function createMcpServer() {
   const server = new McpServer({
     name: 'kiku',
     title: 'kiku',
-    version: '1.1.0',
+    version: PACKAGE_VERSION,
     description: 'MCP server exposing the Ju Jingyi catalog as tools, resources, and prompts.',
     websiteUrl: 'https://jujingyi-kikuuu.vercel.app/',
     icons: [

package/src/data/brandsData.js

@@ -50,6 +50,19 @@ export const brandsData = {
       accentBg: "bg-purple-500/10 text-purple-600 border-purple-200 dark:border-purple-800",
       tier: "Global Luxury"
     },
+    {
+      id: "versace",
+      year: 2025,
+      brandNameEn: "Versace / Versace Fragrance",
+      brandNameCn: "范思哲香氛",
+      title: "Global Fragrance Ambassador (แบรนด์แอมบาสเดอร์ระดับโลกฝ่ายน้ำหอม)",
+      category: "น้ำหอมและแฟชั่นหรูระดับโลก (Luxury Italian Fashion & Fragrance)",
+      highlight: "ตัวแทนภาพลักษณ์ระดับสากลของ Versace Dylan Purple & Luxury Fragrance",
+      isGlobal: true,
+      logoColor: "from-amber-600 to-yellow-700",
+      accentBg: "bg-amber-500/10 text-amber-600 border-amber-200 dark:border-amber-800",
+      tier: "Global High Luxury"
+    },
     {
       id: "fred",
       year: 2025,
@@ -63,6 +76,58 @@ export const brandsData = {
       accentBg: "bg-sky-500/10 text-sky-600 border-sky-200 dark:border-sky-800",
       tier: "LVMH High Jewelry"
     },
+    {
+      id: "makeup-forever",
+      year: 2024,
+      brandNameEn: "MAKE UP FOR EVER",
+      brandNameCn: "玫珂菲 (LVMH)",
+      title: "Brand Ambassador (ภูมิภาคเอเชียแปซิฟิก)",
+      category: "เครื่องสำอางระดับมืออาชีพจากฝรั่งเศส (French Professional Makeup)",
+      highlight: "แบรนด์เครื่องสำอางชั้นนำในเครือ LVMH ถ่ายทอดภาพลักษณ์ลุคเมกอัปอันสมบูรณ์แบบ",
+      isGlobal: false,
+      logoColor: "from-neutral-800 to-black",
+      accentBg: "bg-neutral-500/10 text-neutral-700 dark:text-neutral-300 border-neutral-200 dark:border-neutral-700",
+      tier: "LVMH Professional Beauty"
+    },
+    {
+      id: "mistine",
+      year: 2024,
+      brandNameEn: "Mistine",
+      brandNameCn: "蜜丝婷",
+      title: "Global Sunscreen & Beauty Ambassador (แบรนด์แอมบาสเดอร์ระดับโลก)",
+      category: "ผลิตภัณฑ์กันแดดและความงามระดับเอเชีย (Sunscreen & Color Cosmetics)",
+      highlight: "พรีเซนเตอร์ไลน์ครีมกันแดดและเมกอัปอันดับ 1 ที่ได้รับความนิยมอย่างล้นหลามทั่วเอเชีย",
+      isGlobal: true,
+      logoColor: "from-orange-500 to-amber-600",
+      accentBg: "bg-orange-500/10 text-orange-600 border-orange-200 dark:border-orange-800",
+      tier: "Asian Beauty Titan"
+    },
+    {
+      id: "maybelline",
+      year: 2023,
+      brandNameEn: "Maybelline New York",
+      brandNameCn: "美宝莲纽约 (L'Oréal)",
+      title: "Brand Ambassador",
+      category: "เครื่องสำอางระดับโลก (Global Makeup)",
+      highlight: "แคมเปญลิปสติกและรองพื้นไวรัลระดับอินเตอร์เนชันแนล",
+      isGlobal: false,
+      logoColor: "from-rose-600 to-pink-700",
+      accentBg: "bg-rose-500/10 text-rose-600 border-rose-200 dark:border-rose-800",
+      tier: "Global Cosmetics"
+    },
+    {
+      id: "ysl-beauty",
+      year: 2023,
+      brandNameEn: "YSL Beauty",
+      brandNameCn: "圣罗兰美妆 (L'Oréal Luxe)",
+      title: "Brand Friend & Campaign Ambassador",
+      category: "เครื่องสำอางและน้ำหอมลักชัวรี (French Luxury Beauty)",
+      highlight: "ร่วมงานแคมเปญลิปสติกและน้ำหอม Libre สุดไอคอนิก",
+      isGlobal: false,
+      logoColor: "from-stone-900 to-zinc-950",
+      accentBg: "bg-zinc-500/10 text-zinc-700 dark:text-zinc-300 border-zinc-200 dark:border-zinc-700",
+      tier: "Luxury Haute Beauty"
+    },
     {
       id: "mac",
       year: 2025,