lanhu-layer-tree 1.0.0

package/src/client.ts

@@ -0,0 +1,490 @@
+import axios, { AxiosInstance } from 'axios';
+import { LanhuConfig, ParsedUrl, DesignsResponse, LayersResponse, SlicesResponse, Design, Layer, Slice } from './types';
+import { parseUrl, normalizeColor } from './utils';
+import { buildCookie, refreshCookieFromChrome, AUTH_ERROR_CODES } from './cookie';
+
+const BASE_URL = 'https://lanhuapp.com';
+const HTTP_TIMEOUT = 60000;
+
+/**
+ * 蓝湖 API 客户端
+ */
+export class LanhuClient {
+  private cookie: string;
+  private baseUrl: string;
+  private timeout: number;
+  private client: AxiosInstance;
+  private defaultTid?: string;
+  private cookieRefreshAttempted: boolean = false;
+  private cookieInitialized: boolean = false;
+
+  constructor(config: LanhuConfig = {}) {
+    this.cookie = config.cookie || buildCookie();
+    this.baseUrl = config.baseUrl || BASE_URL;
+    this.timeout = config.timeout || HTTP_TIMEOUT;
+    this.defaultTid = process.env.TID;
+
+    // 如果构造时已有 cookie，标记为已初始化
+    if (this.cookie && this.cookie !== 'your_lanhu_cookie_here') {
+      this.cookieInitialized = true;
+    }
+
+    this.client = this.buildClient();
+  }
+
+  /**
+   * 异步初始化：当 cookie 缺失时自动尝试从 Chrome 读取（仅首次）
+   */
+  async ensureCookie(): Promise<void> {
+    if (this.cookieInitialized) return;
+
+    console.log('🔄 未找到蓝湖 cookie 配置，尝试从 Chrome 自动获取...');
+    const refreshed = await refreshCookieFromChrome();
+    if (!refreshed) {
+      throw new Error(
+        '❌ 无法获取蓝湖 cookie。请确保：\n' +
+        '  1. Chrome 浏览器已登录 lanhuapp.com\n' +
+        '  2. 已安装 chrome-cookies-secure: npm install chrome-cookies-secure\n' +
+        '  或手动在 .env 文件中配置 SESSION 和 USER_TOKEN'
+      );
+    }
+    this.cookie = refreshed;
+    this.cookieInitialized = true;
+    this.client = this.buildClient();
+  }
+
+  private buildClient(): AxiosInstance {
+    return axios.create({
+      timeout: this.timeout,
+      headers: {
+        'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36',
+        'Referer': 'https://lanhuapp.com/web/',
+        'Accept': 'application/json, text/plain, */*',
+        'Cookie': this.cookie,
+        'sec-ch-ua': '"Chromium";v="142", "Google Chrome";v="142", "Not_A Brand";v="99"',
+        'sec-ch-ua-mobile': '?0',
+        'sec-ch-ua-platform': '"macOS"',
+        'request-from': 'web',
+        'real-path': '/item/project/product'
+      }
+    });
+  }
+
+  /**
+   * 带认证错误自动刷新的 GET 请求
+   */
+  private async requestGet(url: string, requestConfig: any = {}): Promise<any> {
+    await this.ensureCookie();
+    let response = await this.client.get(url, requestConfig);
+    const data = response.data;
+    const code = data && typeof data === 'object' ? String(data.code ?? '') : '';
+
+    if (AUTH_ERROR_CODES.has(code) && !this.cookieRefreshAttempted) {
+      this.cookieRefreshAttempted = true;
+      console.log(`🔄 蓝湖 API 认证错误 (code=${code})，尝试刷新 cookie...`);
+      const newCookie = await refreshCookieFromChrome();
+      if (newCookie) {
+        this.cookie = newCookie;
+        this.client = this.buildClient();
+        response = await this.client.get(url, requestConfig);
+      }
+      this.cookieRefreshAttempted = false;
+    }
+    return response;
+  }
+
+  /**
+   * 获取设计图列表
+   */
+  async getDesigns(url: string): Promise<DesignsResponse> {
+    const params = parseUrl(url, this.defaultTid);
+    const apiUrl = `${this.baseUrl}/api/project/images`;
+
+    const response = await this.requestGet(apiUrl, {
+      params: {
+        project_id: params.project_id,
+        team_id: params.team_id,
+        dds_status: 1,
+        position: 1,
+        show_cb_src: 1,
+        comment: 1
+      }
+    });
+
+    const data = response.data;
+
+    if (data.code !== '00000') {
+      return {
+        status: 'error',
+        message: data.msg || 'Unknown error'
+      };
+    }
+
+    const projectData = data.data || {};
+    const images = projectData.images || [];
+    const designList: Design[] = images.map((img: any, idx: number) => ({
+      index: idx + 1,
+      id: img.id,
+      name: img.name,
+      width: img.width,
+      height: img.height,
+      url: img.url,
+      update_time: img.update_time
+    }));
+
+    return {
+      status: 'success',
+      project_name: projectData.name,
+      total_designs: designList.length,
+      designs: designList
+    };
+  }
+
+  /**
+   * 获取设计图图层信息
+   */
+  async getDesignLayers(url: string, designId: string): Promise<LayersResponse> {
+    const params = parseUrl(url, this.defaultTid);
+    const apiUrl = `${this.baseUrl}/api/project/image`;
+
+    const response = await this.requestGet(apiUrl, {
+      params: {
+        dds_status: 1,
+        image_id: designId,
+        team_id: params.team_id,
+        project_id: params.project_id
+      }
+    });
+
+    const data = response.data;
+
+    if (data.code !== '00000') {
+      throw new Error(`Failed to get design: ${data.msg || 'Unknown error'}`);
+    }
+
+    const result = data.result;
+    const latestVersion = result.versions[0];
+    const jsonUrl = latestVersion.json_url;
+
+    // 获取 sketch 数据
+    const jsonResponse = await this.requestGet(jsonUrl);
+    const sketchData = jsonResponse.data;
+
+    // 解析画板尺寸
+    let abLeft = 0, abTop = 0, abWidth = 0, abHeight = 0;
+    const board = sketchData.board || {};
+    if (board.artboard?.artboardRect) {
+      const rect = board.artboard.artboardRect;
+      abLeft = rect.left || 0;
+      abTop = rect.top || 0;
+      abWidth = (rect.right || 0) - abLeft;
+      abHeight = (rect.bottom || 0) - abTop;
+    }
+
+    const layers: Layer[] = [];
+    const seenIds = new Set<string>();
+
+    // 递归提取图层
+    const extractLayer = (obj: any, depth: number = 0, parentPath: string = '') => {
+      if (!obj || typeof obj !== 'object') return;
+
+      const name = obj.name || '';
+      const ltype = obj.type || '';
+      const visible = obj.visible !== false;
+
+      if (!name || !visible) {
+        if (obj.layers) {
+          obj.layers.forEach((sub: any) => extractLayer(sub, depth, parentPath));
+        }
+        return;
+      }
+
+      const dedupKey = `${obj.id}_${name}_${depth}`;
+      if (seenIds.has(dedupKey)) return;
+      seenIds.add(dedupKey);
+
+      // 使用 ID 确保 path 唯一性
+      const layerId = obj.id || '';
+      const pathSegment = layerId ? `${name}#${layerId}` : name;
+      const currentPath = parentPath ? `${parentPath}/${pathSegment}` : pathSegment;
+
+      let w = obj.width || 0;
+      let h = obj.height || 0;
+      const bounds = obj._orgBounds || obj.bounds || obj.boundsWithFX || {};
+      let x = (bounds.left || 0) - abLeft;
+      let y = (bounds.top || 0) - abTop;
+
+      if (!w && bounds.right && bounds.left) {
+        w = bounds.right - bounds.left;
+      }
+      if (!h && bounds.bottom && bounds.top) {
+        h = bounds.bottom - bounds.top;
+      }
+
+      const layerInfo: Layer = {
+        name,
+        type: ltype,
+        width: Math.round(w),
+        height: Math.round(h),
+        x: Math.round(x),
+        y: Math.round(y),
+        path: currentPath,
+        depth
+      };
+
+      // smartObject.originalFileName
+      if (obj.smartObject) {
+        layerInfo.smart_object = obj.smartObject.originalFileName || name;
+      }
+
+      // 处理文本图层
+      if (ltype === 'textLayer') {
+        const textInfo = obj.textInfo || {};
+        const textData = obj.text;
+
+        if (textInfo.text) {
+          layerInfo.text = textInfo.text;
+        } else if (textData && typeof textData === 'object' && textData.textKey) {
+          layerInfo.text = textData.textKey;
+        }
+
+        const textStyle: any = {};
+        if (textInfo.color) textStyle.fill_color = normalizeColor(textInfo.color);
+        if (textInfo.size) textStyle.font_size = textInfo.size;
+        if (textInfo.fontName) textStyle.font_name = textInfo.fontName;
+
+        // 从 textStyleRange 获取样式
+        const textStyleRange = textInfo.textStyleRange || [];
+        if (textStyleRange.length > 0) {
+          const ts = textStyleRange[0].textStyle || {};
+          if (!textStyle.fill_color && ts.color) {
+            textStyle.fill_color = normalizeColor(ts.color);
+          }
+          if (!textStyle.font_size && ts.size) {
+            textStyle.font_size = typeof ts.size === 'object' ? ts.size.value : ts.size;
+          }
+          if (!textStyle.font_name && ts.fontName) {
+            textStyle.font_name = ts.fontName;
+          }
+        }
+
+        // layerEffects.frameFX → 描边
+        const layerFx = obj.layerEffects || {};
+        const frameFx = layerFx.frameFX || {};
+        if (frameFx.enabled && frameFx.color) {
+          textStyle.stroke_color = normalizeColor(frameFx.color);
+          if (frameFx.size) {
+            textStyle.stroke_width = frameFx.size;
+          }
+        }
+
+        // layerEffects.dropShadow → 阴影
+        const dropShadow = layerFx.dropShadow || {};
+        if (dropShadow.enabled && dropShadow.color) {
+          textStyle.shadow_color = normalizeColor(dropShadow.color);
+        }
+
+        // obj.textStyle 后备字段
+        const layerTs = obj.textStyle || {};
+        if (layerTs) {
+          if (!textStyle.fill_color && layerTs.color) {
+            textStyle.fill_color = normalizeColor(layerTs.color);
+          }
+          if (!textStyle.font_size && layerTs.fontSize) {
+            textStyle.font_size = layerTs.fontSize;
+          }
+          if (!textStyle.font_name && layerTs.fontName) {
+            textStyle.font_name = layerTs.fontName;
+          }
+        }
+
+        // obj.fills[*].color 作为 fill_color 后备
+        if (!textStyle.fill_color && Array.isArray(obj.fills)) {
+          for (const fill of obj.fills) {
+            if (fill && fill.color) {
+              textStyle.fill_color = normalizeColor(fill.color);
+              break;
+            }
+          }
+        }
+
+        // obj.strokes / obj.borders 作为 stroke 后备
+        if (!textStyle.stroke_color) {
+          const strokeList = obj.strokes || obj.borders || [];
+          for (const stroke of strokeList) {
+            if (!stroke) continue;
+            if (stroke.color) {
+              textStyle.stroke_color = normalizeColor(stroke.color);
+            }
+            if (stroke.width) {
+              textStyle.stroke_width = stroke.width;
+            }
+            break;
+          }
+        }
+
+        if (Object.keys(textStyle).length > 0) {
+          layerInfo.text_style = textStyle;
+        }
+      }
+
+      if (obj.opacity !== undefined && obj.opacity !== 255) {
+        layerInfo.opacity = Math.round((obj.opacity / 255) * 100);
+      }
+
+      layers.push(layerInfo);
+
+      // 递归处理子图层
+      if (obj.layers) {
+        obj.layers.forEach((sub: any) => extractLayer(sub, depth + 1, currentPath));
+      }
+    };
+
+    // 开始提取图层
+    if (board.layers) {
+      board.layers.forEach((item: any) => extractLayer(item, 0));
+    } else if (sketchData.artboard?.layers) {
+      sketchData.artboard.layers.forEach((item: any) => extractLayer(item, 0));
+    } else if (sketchData.info && sketchData.info.length > 0) {
+      const first = sketchData.info[0];
+      if (first.layers) {
+        first.layers.forEach((item: any) => extractLayer(item, 0));
+      } else {
+        sketchData.info.forEach((item: any) => extractLayer(item, 0));
+      }
+    }
+
+    return {
+      design_id: designId,
+      design_name: result.name,
+      version: latestVersion.version_info,
+      canvas_size: {
+        width: abWidth > 0 ? abWidth : result.width,
+        height: abHeight > 0 ? abHeight : result.height
+      },
+      total_layers: layers.length,
+      layers
+    };
+  }
+
+  /**
+   * 下载设计图截图
+   */
+  async downloadScreenshot(design: Design, outputPath: string): Promise<boolean> {
+    try {
+      const imgUrl = design.url.split('?')[0];
+      const response = await this.client.get(imgUrl, {
+        responseType: 'arraybuffer'
+      });
+
+      const fs = await import('fs/promises');
+      const path = await import('path');
+
+      await fs.mkdir(path.dirname(outputPath), { recursive: true });
+      await fs.writeFile(outputPath, response.data);
+
+      return true;
+    } catch (error) {
+      console.error(`⚠️ 下载截图失败 (${design.name}):`, error);
+      return false;
+    }
+  }
+
+  /**
+   * 获取设计图的切图/资源列表
+   */
+  async getDesignSlices(url: string, designId: string): Promise<SlicesResponse> {
+    const params = parseUrl(url, this.defaultTid);
+    const apiUrl = `${this.baseUrl}/api/project/image`;
+
+    const response = await this.requestGet(apiUrl, {
+      params: {
+        dds_status: 1,
+        image_id: designId,
+        team_id: params.team_id,
+        project_id: params.project_id
+      }
+    });
+
+    const data = response.data;
+    if (data.code !== '00000') {
+      throw new Error(`Failed to get design: ${data.msg || 'Unknown error'}`);
+    }
+
+    const result = data.result;
+    const latestVersion = result.versions[0];
+    const jsonResponse = await this.requestGet(latestVersion.json_url);
+    const sketchData = jsonResponse.data;
+
+    const slices: Slice[] = [];
+
+    const findSlices = (obj: any, layerPath: string = '') => {
+      if (!obj || typeof obj !== 'object') return;
+      const currentName = obj.name || '';
+      const currentPath = layerPath ? `${layerPath}/${currentName}` : currentName;
+
+      let downloadUrl: string | null = null;
+      let fmt = 'png';
+      let frame: any = {};
+
+      if (obj.image && (obj.image.imageUrl || obj.image.svgUrl)) {
+        downloadUrl = obj.image.imageUrl || obj.image.svgUrl;
+        frame = obj.frame || obj.bounds || {};
+        fmt = obj.image.imageUrl ? 'png' : 'svg';
+      } else if (obj.ddsImage && obj.ddsImage.imageUrl) {
+        downloadUrl = obj.ddsImage.imageUrl;
+        frame = obj;
+        fmt = 'png';
+      }
+
+      if (downloadUrl) {
+        const w = frame.width ?? ((frame.right || 0) - (frame.left || 0));
+        const h = frame.height ?? ((frame.bottom || 0) - (frame.top || 0));
+        slices.push({
+          name: currentName,
+          download_url: downloadUrl,
+          size: w && h ? `${Math.round(w)}x${Math.round(h)}` : 'unknown',
+          format: fmt,
+          layer_path: currentPath
+        });
+      }
+
+      if (obj.layers) {
+        obj.layers.forEach((layer: any) => findSlices(layer, currentPath));
+      }
+    };
+
+    if (sketchData.artboard?.layers) {
+      sketchData.artboard.layers.forEach((layer: any) => findSlices(layer));
+    } else if (sketchData.info) {
+      sketchData.info.forEach((item: any) => findSlices(item));
+    }
+
+    return {
+      design_id: designId,
+      design_name: result.name,
+      version: latestVersion.version_info,
+      canvas_size: { width: result.width, height: result.height },
+      total_slices: slices.length,
+      slices
+    };
+  }
+
+  /**
+   * 下载单个切图
+   */
+  async downloadSlice(slice: Slice, outputPath: string): Promise<boolean> {
+    try {
+      const url = slice.download_url.split('?')[0];
+      const response = await this.client.get(url, { responseType: 'arraybuffer' });
+      const fs = await import('fs/promises');
+      const path = await import('path');
+      await fs.mkdir(path.dirname(outputPath), { recursive: true });
+      await fs.writeFile(outputPath, response.data);
+      return true;
+    } catch (error) {
+      console.error(`⚠️ 下载切图失败 (${slice.name}):`, error);
+      return false;
+    }
+  }
+}

package/src/cookie.ts

@@ -0,0 +1,156 @@
+/**
+ * Cookie 管理：从 Chrome 自动读取蓝湖 cookie，并维护 .env 配置
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+
+export interface LanhuCookieFields {
+  SESSION: string;
+  USER_TOKEN: string;
+  HM_LVT_KEY: string;
+  HM_LVT_VALUE: string;
+}
+
+/**
+ * 从 SESSION/USER_TOKEN/HM_LVT 等环境变量拼装 Cookie 字符串
+ *
+ * 兼容两种格式：
+ *  - SESSION 已是完整 cookie（包含 user_token=）→ 直接使用
+ *  - 否则按字段拼装
+ */
+export function buildCookie(): string {
+  const sessionValue = process.env.SESSION || '';
+
+  if (sessionValue.includes('user_token=')) {
+    return sessionValue;
+  }
+
+  const parts: string[] = [];
+  if (sessionValue) parts.push(`session=${sessionValue}`);
+  if (process.env.USER_TOKEN) parts.push(`user_token=${process.env.USER_TOKEN}`);
+
+  const hmKey = process.env.HM_LVT_KEY || '';
+  const hmVal = process.env.HM_LVT_VALUE || '';
+  if (hmKey && hmVal) parts.push(`${hmKey}=${hmVal}`);
+
+  return parts.join(';');
+}
+
+/**
+ * 从 Chrome 浏览器读取 lanhuapp.com 的 cookie
+ *
+ * 使用 chrome-cookies-secure 跨平台读取（macOS Keychain / Windows DPAPI / Linux GNOME Keyring）
+ */
+export async function getLanhuCookiesFromChrome(): Promise<LanhuCookieFields | null> {
+  let chromeCookies: any;
+  try {
+    chromeCookies = require('chrome-cookies-secure');
+  } catch {
+    console.warn('⚠️ chrome-cookies-secure 未安装，无法自动刷新 cookie。请运行: npm install chrome-cookies-secure');
+    return null;
+  }
+
+  const cookies = await new Promise<Record<string, string>>((resolve, reject) => {
+    chromeCookies.getCookies(
+      'https://lanhuapp.com/',
+      'object',
+      (err: any, result: Record<string, string>) => {
+        if (err) reject(err);
+        else resolve(result || {});
+      }
+    );
+  }).catch((err: any) => {
+    console.warn(`⚠️ 从 Chrome 读取 cookie 失败: ${err?.message || err}`);
+    return {} as Record<string, string>;
+  });
+
+  const session = cookies['session'] || '';
+  const userToken = cookies['user_token'] || '';
+
+  if (!session && !userToken) {
+    console.warn('⚠️ Chrome 中未找到蓝湖 cookie，请确认 Chrome 中已登录 lanhuapp.com');
+    return null;
+  }
+
+  let hmKey = '';
+  let hmVal = '';
+  for (const [name, value] of Object.entries(cookies)) {
+    if (name.startsWith('Hm_lvt_')) {
+      hmKey = name;
+      hmVal = value;
+      break;
+    }
+  }
+
+  return {
+    SESSION: session,
+    USER_TOKEN: userToken,
+    HM_LVT_KEY: hmKey,
+    HM_LVT_VALUE: hmVal
+  };
+}
+
+/**
+ * 将 cookie 字段写入 .env 文件
+ */
+function updateEnvFile(fields: LanhuCookieFields, envFile: string): void {
+  if (!fs.existsSync(envFile)) return;
+
+  let content = fs.readFileSync(envFile, 'utf-8');
+  for (const [key, val] of Object.entries(fields)) {
+    if (!val) continue;
+    const newLine = `${key}="${val}"`;
+    const re = new RegExp(`^${key}=.*$`, 'm');
+    if (re.test(content)) {
+      content = content.replace(re, newLine);
+    } else {
+      content += `\n${newLine}\n`;
+    }
+  }
+  fs.writeFileSync(envFile, content, 'utf-8');
+}
+
+/**
+ * 从 Chrome 读取蓝湖 cookie，更新 .env 文件，返回拼装好的 cookie 字符串
+ */
+export async function refreshCookieFromChrome(envPath?: string): Promise<string> {
+  const fields = await getLanhuCookiesFromChrome();
+  if (!fields) return '';
+
+  // 同步到当前进程环境变量，让 buildCookie 后续调用也能读到
+  process.env.SESSION = fields.SESSION;
+  process.env.USER_TOKEN = fields.USER_TOKEN;
+  if (fields.HM_LVT_KEY) {
+    process.env.HM_LVT_KEY = fields.HM_LVT_KEY;
+    process.env.HM_LVT_VALUE = fields.HM_LVT_VALUE;
+  }
+
+  const envFile = envPath || path.resolve(process.cwd(), '.env');
+
+  // 如果 .env 不存在，创建它
+  if (!fs.existsSync(envFile)) {
+    const content = [
+      '# 蓝湖 Cookie 配置（自动生成）',
+      `SESSION="${fields.SESSION}"`,
+      `USER_TOKEN="${fields.USER_TOKEN}"`,
+      fields.HM_LVT_KEY ? `${fields.HM_LVT_KEY}="${fields.HM_LVT_VALUE}"` : '',
+      '# TID=your_default_team_id',
+      ''
+    ].filter(Boolean).join('\n');
+    fs.writeFileSync(envFile, content, 'utf-8');
+    console.log(`✅ 已从 Chrome 读取蓝湖 cookie 并创建 ${envFile}`);
+  } else {
+    updateEnvFile(fields, envFile);
+    console.log(`✅ 已从 Chrome 刷新蓝湖 cookie → ${envFile}`);
+  }
+
+  const parts = [`session=${fields.SESSION}`, `user_token=${fields.USER_TOKEN}`];
+  if (fields.HM_LVT_KEY) parts.push(`${fields.HM_LVT_KEY}=${fields.HM_LVT_VALUE}`);
+  return parts.join(';');
+}
+
+/**
+ * 蓝湖认证错误码
+ */
+export const AUTH_ERROR_CODES = new Set(['10000', '10001', '10002', '99999', 'A0001']);