a27e3b8e43
Optimized the root .gitignore to exclude virtual environments, node modules, and temp folders to ensure clean and lightweight version tracking. Co-authored-by: Cursor <cursoragent@cursor.com>
2358 lines
100 KiB
TypeScript
2358 lines
100 KiB
TypeScript
import type { Plugin } from 'vite';
|
||
import path from 'path';
|
||
import fs from 'fs';
|
||
import { IncomingMessage } from 'http';
|
||
import formidable from 'formidable';
|
||
import extractZip from 'extract-zip';
|
||
import archiver from 'archiver';
|
||
import { allowedItemKeysByTab, scanEntries, type SidebarTreeTab } from './utils/entryScanner';
|
||
import { createSidebarTreeStore, type SidebarTreeNode, type ResourceOrderType } from './utils/sidebarTreeStore';
|
||
import { buildAttachmentContentDisposition } from './utils/contentDisposition';
|
||
import { ensureTemplatesDirMigrated, getTemplatesDir } from './utils/docUtils';
|
||
import { getInstallSkillTargetDir } from './utils/installSkillTargets';
|
||
import { runCommand, runCommandSync } from '../scripts/utils/command-runtime.mjs';
|
||
|
||
/**
|
||
* 递归复制目录（用于 Windows 权限问题的备用方案）
|
||
*
|
||
* 当 fs.renameSync() 因权限问题失败时（EPERM 错误），使用此函数作为 fallback。
|
||
*
|
||
* 为什么 copy 比 rename 更可靠？
|
||
* - rename：只修改文件系统元数据（inode），对权限和文件占用非常敏感
|
||
* - copy：实际读取和写入数据，只要文件可读就能复制，绕过了很多权限限制
|
||
*
|
||
* 常见触发场景：
|
||
* - Windows 杀毒软件扫描导致文件被锁定
|
||
* - 跨驱动器移动文件（rename 不支持）
|
||
* - 文件索引服务占用文件句柄
|
||
* - 路径包含中文字符导致的编码问题
|
||
*
|
||
* @param src - 源目录路径
|
||
* @param dest - 目标目录路径
|
||
*/
|
||
function copyDirRecursive(src: string, dest: string) {
|
||
// 确保目标目录存在
|
||
if (!fs.existsSync(dest)) {
|
||
fs.mkdirSync(dest, { recursive: true });
|
||
}
|
||
|
||
// 读取源目录的所有内容
|
||
const entries = fs.readdirSync(src, { withFileTypes: true });
|
||
|
||
// 逐个处理文件和子目录
|
||
for (const entry of entries) {
|
||
const srcPath = path.join(src, entry.name);
|
||
const destPath = path.join(dest, entry.name);
|
||
|
||
if (entry.isDirectory()) {
|
||
// 递归处理子目录
|
||
copyDirRecursive(srcPath, destPath);
|
||
} else {
|
||
// 复制文件
|
||
fs.copyFileSync(srcPath, destPath);
|
||
}
|
||
}
|
||
}
|
||
|
||
const IGNORED_EXTRACT_ENTRIES = new Set(['__MACOSX', '.DS_Store']);
|
||
|
||
function truncateName(name: string, maxLength: number) {
|
||
return name.length > maxLength ? name.slice(0, maxLength) : name;
|
||
}
|
||
|
||
function sanitizeFolderName(name: string) {
|
||
return name
|
||
.replace(/[^a-z0-9-]/gi, '-')
|
||
.replace(/-+/g, '-')
|
||
.replace(/^-|-$/g, '')
|
||
.toLowerCase();
|
||
}
|
||
|
||
function inferExtractedRootFolder(extractDir: string) {
|
||
if (!fs.existsSync(extractDir)) {
|
||
return { entryCount: 0, hasRootFolder: false, rootFolderName: '' };
|
||
}
|
||
|
||
const entries = fs
|
||
.readdirSync(extractDir, { withFileTypes: true })
|
||
.filter(entry => !IGNORED_EXTRACT_ENTRIES.has(entry.name));
|
||
|
||
if (entries.length === 1 && entries[0].isDirectory()) {
|
||
return { entryCount: entries.length, hasRootFolder: true, rootFolderName: entries[0].name };
|
||
}
|
||
|
||
return { entryCount: entries.length, hasRootFolder: false, rootFolderName: '' };
|
||
}
|
||
|
||
function sanitizeRelativePath(input: string) {
|
||
const normalized = input.replace(/\\/g, '/');
|
||
const parts = normalized.split('/').filter(part => part && part !== '.' && part !== '..');
|
||
return parts.join('/');
|
||
}
|
||
|
||
function deriveRootFolderName(paths: string[]) {
|
||
const roots = new Set<string>();
|
||
for (const rawPath of paths) {
|
||
const cleaned = sanitizeRelativePath(rawPath);
|
||
if (!cleaned) continue;
|
||
const [root] = cleaned.split('/');
|
||
if (root) roots.add(root);
|
||
}
|
||
return roots.size === 1 ? Array.from(roots)[0] : '';
|
||
}
|
||
|
||
function hasIgnoredEntry(relativePath: string) {
|
||
return relativePath.split('/').some(segment => IGNORED_EXTRACT_ENTRIES.has(segment));
|
||
}
|
||
|
||
function moveFileWithFallback(srcPath: string, destPath: string) {
|
||
try {
|
||
fs.renameSync(srcPath, destPath);
|
||
} catch {
|
||
fs.copyFileSync(srcPath, destPath);
|
||
fs.unlinkSync(srcPath);
|
||
}
|
||
}
|
||
|
||
const SUPPORTED_UPLOAD_TARGET_TYPES = ['prototypes', 'components', 'themes'] as const;
|
||
const THEME_IMPORT_SUPPORTED_UPLOAD_TYPES = new Set(['local_axure', 'v0', 'google_aistudio', 'figma_make']);
|
||
const THEME_IMPORT_SUB_SKILL_DOCS = [
|
||
'/skills/axure-prototype-workflow/theme-generation.md',
|
||
'/skills/axure-prototype-workflow/doc-generation.md',
|
||
'/skills/axure-prototype-workflow/data-generation.md',
|
||
'/skills/web-page-workflow/theme-generation.md',
|
||
'/skills/web-page-workflow/doc-generation.md',
|
||
'/skills/web-page-workflow/data-generation.md',
|
||
];
|
||
|
||
function formatReferenceList(referencePaths: string[]) {
|
||
return referencePaths.map((referencePath) => `- \`${referencePath}\``).join('\n');
|
||
}
|
||
|
||
/**
|
||
* 文件系统 API 插件
|
||
* 提供文件和目录的基本操作功能：删除、重命名、复制等
|
||
*/
|
||
export function fileSystemApiPlugin(): Plugin {
|
||
return {
|
||
name: 'filesystem-api',
|
||
|
||
configureServer(server) {
|
||
const projectRoot = process.cwd();
|
||
const nodeCommand = process.execPath;
|
||
const entriesPath = path.join(projectRoot, '.axhub', 'make', 'entries.json');
|
||
const configPath = path.join(projectRoot, '.axhub', 'make', 'axhub.config.json');
|
||
const DEFAULT_PROJECT_TITLE = '未命名项目';
|
||
const SIDEBAR_TREE_VERSION = 1;
|
||
const templateMigrationResult = ensureTemplatesDirMigrated(projectRoot);
|
||
if (templateMigrationResult.conflicts.length > 0) {
|
||
console.error(
|
||
'[filesystem-api] Template migration conflicts detected:\n' +
|
||
templateMigrationResult.conflicts
|
||
.map((conflict) => `- ${conflict.relativePath}\n legacy: ${conflict.legacyPath}\n target: ${conflict.targetPath}`)
|
||
.join('\n'),
|
||
);
|
||
}
|
||
const sidebarTreeStore = createSidebarTreeStore(projectRoot, {
|
||
version: SIDEBAR_TREE_VERSION,
|
||
legacyEntriesPath: entriesPath,
|
||
});
|
||
|
||
const isSidebarTreeTab = (value: string): value is SidebarTreeTab => {
|
||
return value === 'prototypes' || value === 'components' || value === 'docs' || value === 'canvas';
|
||
};
|
||
|
||
const getTabFromRequest = (req: any): SidebarTreeTab | null => {
|
||
try {
|
||
const url = new URL(req.url || '/', 'http://localhost');
|
||
const tab = (url.searchParams.get('tab') || '').trim();
|
||
if (!isSidebarTreeTab(tab)) return null;
|
||
return tab;
|
||
} catch {
|
||
return null;
|
||
}
|
||
};
|
||
|
||
const toDefaultTreeTitle = (itemKey: string) => {
|
||
const name = itemKey.split('/').pop() || itemKey;
|
||
return name
|
||
.replace(/[-_]+/g, ' ')
|
||
.replace(/\s+/g, ' ')
|
||
.trim() || name;
|
||
};
|
||
|
||
const sanitizeNodeId = (value: string) => value.replace(/[^a-zA-Z0-9_-]/g, '-');
|
||
|
||
const buildDefaultSidebarTree = (allowedItemKeys: Set<string>): SidebarTreeNode[] => {
|
||
const keys = Array.from(allowedItemKeys).sort((a, b) => a.localeCompare(b));
|
||
return keys.map((itemKey) => ({
|
||
id: `item-${sanitizeNodeId(itemKey)}`,
|
||
kind: 'item' as const,
|
||
title: toDefaultTreeTitle(itemKey),
|
||
itemKey,
|
||
}));
|
||
};
|
||
|
||
const normalizeAndValidateSidebarTree = (
|
||
tree: unknown,
|
||
tab: SidebarTreeTab,
|
||
allowedItemKeys: Set<string>,
|
||
): { valid: true; tree: SidebarTreeNode[] } | { valid: false; error: string } => {
|
||
if (!Array.isArray(tree)) {
|
||
return { valid: false, error: 'tree must be an array' };
|
||
}
|
||
|
||
const usedIds = new Set<string>();
|
||
const seenItemKeys = new Set<string>();
|
||
const makeUniqueId = (seed: string) => {
|
||
let candidate = seed;
|
||
let count = 1;
|
||
while (usedIds.has(candidate)) {
|
||
count += 1;
|
||
candidate = `${seed}-${count}`;
|
||
}
|
||
usedIds.add(candidate);
|
||
return candidate;
|
||
};
|
||
const normalizeNodes = (nodes: any[], depth: number): SidebarTreeNode[] | null => {
|
||
if (depth > 32) {
|
||
return null;
|
||
}
|
||
const normalized: SidebarTreeNode[] = [];
|
||
for (const rawNode of nodes) {
|
||
if (!rawNode || typeof rawNode !== 'object') {
|
||
return null;
|
||
}
|
||
const id = typeof rawNode.id === 'string' ? rawNode.id.trim() : '';
|
||
const kind = rawNode.kind;
|
||
const title = typeof rawNode.title === 'string' ? rawNode.title.trim() : '';
|
||
if (!id || !title) return null;
|
||
if (kind !== 'folder' && kind !== 'item') {
|
||
return null;
|
||
}
|
||
const nextId = makeUniqueId(id);
|
||
|
||
if (kind === 'item') {
|
||
const itemKey = typeof rawNode.itemKey === 'string' ? rawNode.itemKey.trim() : '';
|
||
if (!itemKey || !itemKey.startsWith(`${tab}/`) || !allowedItemKeys.has(itemKey)) {
|
||
return null;
|
||
}
|
||
if (seenItemKeys.has(itemKey)) {
|
||
continue;
|
||
}
|
||
seenItemKeys.add(itemKey);
|
||
normalized.push({
|
||
id: nextId,
|
||
kind: 'item',
|
||
title,
|
||
itemKey,
|
||
});
|
||
continue;
|
||
}
|
||
|
||
const rawChildren = Array.isArray(rawNode.children) ? rawNode.children : [];
|
||
const children = normalizeNodes(rawChildren, depth + 1);
|
||
if (!children) {
|
||
return null;
|
||
}
|
||
const rawItemKey = typeof rawNode.itemKey === 'string' ? rawNode.itemKey.trim() : '';
|
||
const itemKey = rawItemKey && rawItemKey.startsWith(`${tab}/`) && allowedItemKeys.has(rawItemKey)
|
||
? rawItemKey
|
||
: undefined;
|
||
if (itemKey) {
|
||
seenItemKeys.add(itemKey);
|
||
}
|
||
normalized.push({
|
||
id: nextId,
|
||
kind: 'folder',
|
||
title,
|
||
...(itemKey ? { itemKey } : {}),
|
||
children,
|
||
});
|
||
}
|
||
return normalized;
|
||
};
|
||
|
||
const normalizedTree = normalizeNodes(tree as any[], 0);
|
||
if (!normalizedTree) {
|
||
return { valid: false, error: 'Invalid tree payload' };
|
||
}
|
||
return { valid: true, tree: normalizedTree };
|
||
};
|
||
|
||
const reconcileSidebarTree = (
|
||
tree: SidebarTreeNode[],
|
||
tab: SidebarTreeTab,
|
||
allowedItemKeys: Set<string>,
|
||
): SidebarTreeNode[] => {
|
||
const usedIds = new Set<string>();
|
||
const seenItemKeys = new Set<string>();
|
||
const makeUniqueId = (seed: string) => {
|
||
let candidate = seed;
|
||
let count = 1;
|
||
while (usedIds.has(candidate)) {
|
||
count += 1;
|
||
candidate = `${seed}-${count}`;
|
||
}
|
||
usedIds.add(candidate);
|
||
return candidate;
|
||
};
|
||
|
||
const normalizeNodes = (nodes: SidebarTreeNode[], depth: number): SidebarTreeNode[] => {
|
||
if (!Array.isArray(nodes) || depth > 32) return [];
|
||
const result: SidebarTreeNode[] = [];
|
||
for (const rawNode of nodes) {
|
||
if (!rawNode || typeof rawNode !== 'object') continue;
|
||
const title = typeof rawNode.title === 'string' ? rawNode.title.trim() : '';
|
||
if (!title) continue;
|
||
const rawId = typeof rawNode.id === 'string' ? rawNode.id.trim() : '';
|
||
const id = makeUniqueId(rawId || `node-${Date.now()}`);
|
||
if (rawNode.kind === 'item') {
|
||
const itemKey = typeof rawNode.itemKey === 'string' ? rawNode.itemKey.trim() : '';
|
||
if (!itemKey || !itemKey.startsWith(`${tab}/`) || !allowedItemKeys.has(itemKey)) {
|
||
continue;
|
||
}
|
||
if (seenItemKeys.has(itemKey)) {
|
||
continue;
|
||
}
|
||
seenItemKeys.add(itemKey);
|
||
result.push({ id, kind: 'item', title, itemKey });
|
||
continue;
|
||
}
|
||
if (rawNode.kind === 'folder') {
|
||
const children = normalizeNodes(Array.isArray(rawNode.children) ? rawNode.children : [], depth + 1);
|
||
const rawFolderItemKey = typeof rawNode.itemKey === 'string' ? rawNode.itemKey.trim() : '';
|
||
const folderItemKey = rawFolderItemKey
|
||
&& rawFolderItemKey.startsWith(`${tab}/`)
|
||
&& allowedItemKeys.has(rawFolderItemKey)
|
||
? rawFolderItemKey
|
||
: undefined;
|
||
const folderNode: SidebarTreeNode = { id, kind: 'folder' as const, title, children };
|
||
if (folderItemKey) {
|
||
seenItemKeys.add(folderItemKey);
|
||
folderNode.itemKey = folderItemKey;
|
||
}
|
||
result.push(folderNode);
|
||
}
|
||
}
|
||
return result;
|
||
};
|
||
|
||
const normalizedTree = normalizeNodes(tree, 0);
|
||
const missingItemKeys = Array.from(allowedItemKeys).filter((itemKey) => !seenItemKeys.has(itemKey));
|
||
const nextMissingNodes = missingItemKeys.sort((a, b) => a.localeCompare(b)).map((itemKey) => ({
|
||
id: makeUniqueId(`item-${sanitizeNodeId(itemKey)}`),
|
||
kind: 'item' as const,
|
||
title: toDefaultTreeTitle(itemKey),
|
||
itemKey,
|
||
}));
|
||
return [...nextMissingNodes, ...normalizedTree];
|
||
};
|
||
|
||
const collectSidebarTreeIds = (nodes: SidebarTreeNode[]): Set<string> => {
|
||
const ids = new Set<string>();
|
||
const walk = (list: SidebarTreeNode[]) => {
|
||
for (const node of list) {
|
||
if (!node || typeof node !== 'object') continue;
|
||
const id = typeof node.id === 'string' ? node.id.trim() : '';
|
||
if (id) {
|
||
ids.add(id);
|
||
}
|
||
if (Array.isArray(node.children) && node.children.length > 0) {
|
||
walk(node.children);
|
||
}
|
||
}
|
||
};
|
||
walk(nodes);
|
||
return ids;
|
||
};
|
||
|
||
const createUniqueFolderNodeId = (existingIds: Set<string>) => {
|
||
let candidate = '';
|
||
do {
|
||
const randomSuffix = Math.random().toString(36).slice(2, 8);
|
||
candidate = `folder-${Date.now()}-${randomSuffix}`;
|
||
} while (existingIds.has(candidate));
|
||
return candidate;
|
||
};
|
||
|
||
const createRootFolderTitle = (nodes: SidebarTreeNode[]) => {
|
||
const rootFolderTitles = new Set<string>();
|
||
for (const node of nodes) {
|
||
if (node.kind !== 'folder') continue;
|
||
const title = typeof node.title === 'string' ? node.title.trim() : '';
|
||
if (!title) continue;
|
||
rootFolderTitles.add(title);
|
||
}
|
||
|
||
const defaultTitle = '新建文件夹';
|
||
if (!rootFolderTitles.has(defaultTitle)) {
|
||
return defaultTitle;
|
||
}
|
||
let suffix = 2;
|
||
while (rootFolderTitles.has(`${defaultTitle}-${suffix}`)) {
|
||
suffix += 1;
|
||
}
|
||
return `${defaultTitle}-${suffix}`;
|
||
};
|
||
|
||
const readProjectTitle = (): string => {
|
||
if (!fs.existsSync(configPath)) {
|
||
return DEFAULT_PROJECT_TITLE;
|
||
}
|
||
try {
|
||
const raw = fs.readFileSync(configPath, 'utf8');
|
||
const parsed = JSON.parse(raw);
|
||
const title = typeof parsed?.projectInfo?.name === 'string' ? parsed.projectInfo.name.trim() : '';
|
||
return title || DEFAULT_PROJECT_TITLE;
|
||
} catch {
|
||
return DEFAULT_PROJECT_TITLE;
|
||
}
|
||
};
|
||
|
||
const DOC_EXTENSIONS = new Set(['.md', '.csv', '.json', '.yaml', '.yml', '.txt']);
|
||
const CANVAS_EXT = '.excalidraw';
|
||
|
||
const collectDocItemKeys = (): Set<string> => {
|
||
const docsDir = path.join(projectRoot, 'src', 'docs');
|
||
const keys: string[] = [];
|
||
if (!fs.existsSync(docsDir)) {
|
||
return new Set();
|
||
}
|
||
|
||
const walk = (currentDir: string) => {
|
||
const entries = fs.readdirSync(currentDir, { withFileTypes: true });
|
||
for (const entry of entries) {
|
||
const absolutePath = path.join(currentDir, entry.name);
|
||
if (entry.isDirectory()) {
|
||
walk(absolutePath);
|
||
continue;
|
||
}
|
||
if (!entry.isFile()) continue;
|
||
const ext = path.extname(entry.name).toLowerCase();
|
||
if (!DOC_EXTENSIONS.has(ext)) continue;
|
||
const rel = normalizePath(path.relative(docsDir, absolutePath));
|
||
keys.push(`docs/${rel}`);
|
||
}
|
||
};
|
||
|
||
walk(docsDir);
|
||
keys.sort((a, b) => a.localeCompare(b));
|
||
return new Set(keys);
|
||
};
|
||
|
||
const collectCanvasItemKeys = (): Set<string> => {
|
||
const canvasDir = path.join(projectRoot, 'src', 'canvas');
|
||
const keys: string[] = [];
|
||
if (!fs.existsSync(canvasDir)) {
|
||
return new Set();
|
||
}
|
||
|
||
const entries = fs.readdirSync(canvasDir, { withFileTypes: true });
|
||
for (const entry of entries) {
|
||
if (!entry.isFile() || !entry.name.endsWith(CANVAS_EXT)) continue;
|
||
keys.push(`canvas/${entry.name}`);
|
||
}
|
||
|
||
keys.sort((a, b) => a.localeCompare(b));
|
||
return new Set(keys);
|
||
};
|
||
|
||
const resolveAllowedItemKeys = (tab: SidebarTreeTab): Set<string> => {
|
||
if (tab === 'docs') {
|
||
return collectDocItemKeys();
|
||
}
|
||
if (tab === 'canvas') {
|
||
return collectCanvasItemKeys();
|
||
}
|
||
const scanned = scanEntries(projectRoot);
|
||
return allowedItemKeysByTab(scanned.entries.js, tab);
|
||
};
|
||
|
||
const isResourceOrderType = (value: string): value is ResourceOrderType => {
|
||
return value === 'themes' || value === 'data' || value === 'templates';
|
||
};
|
||
|
||
const getResourceOrderTypeFromRequest = (req: any): ResourceOrderType | null => {
|
||
try {
|
||
const url = new URL(req.url || '/', 'http://localhost');
|
||
const type = (url.searchParams.get('type') || '').trim();
|
||
if (!isResourceOrderType(type)) return null;
|
||
return type;
|
||
} catch {
|
||
return null;
|
||
}
|
||
};
|
||
|
||
const collectThemeKeys = (): Set<string> => {
|
||
const themesDir = path.join(projectRoot, 'src', 'themes');
|
||
const keys = new Set<string>();
|
||
if (!fs.existsSync(themesDir)) {
|
||
return keys;
|
||
}
|
||
const entries = fs.readdirSync(themesDir, { withFileTypes: true });
|
||
for (const entry of entries) {
|
||
if (!entry.isDirectory()) continue;
|
||
keys.add(entry.name);
|
||
}
|
||
return keys;
|
||
};
|
||
|
||
const collectDataTableKeys = (): Set<string> => {
|
||
const databaseDir = path.join(projectRoot, 'src', 'database');
|
||
const keys = new Set<string>();
|
||
if (!fs.existsSync(databaseDir)) {
|
||
return keys;
|
||
}
|
||
const entries = fs.readdirSync(databaseDir, { withFileTypes: true });
|
||
for (const entry of entries) {
|
||
if (!entry.isFile() || !entry.name.endsWith('.json')) continue;
|
||
const fileName = entry.name.replace(/\.json$/i, '');
|
||
if (fileName) {
|
||
keys.add(fileName);
|
||
}
|
||
}
|
||
return keys;
|
||
};
|
||
|
||
const resolveAllowedResourceKeys = (type: ResourceOrderType): Set<string> => {
|
||
if (type === 'themes') {
|
||
return collectThemeKeys();
|
||
}
|
||
if (type === 'data') {
|
||
return collectDataTableKeys();
|
||
}
|
||
const templatesDir = getTemplatesDir(projectRoot);
|
||
const keys = new Set<string>();
|
||
if (!fs.existsSync(templatesDir)) {
|
||
return keys;
|
||
}
|
||
const walkTemplatesDir = (dirPath: string) => {
|
||
const entries = fs.readdirSync(dirPath, { withFileTypes: true });
|
||
for (const entry of entries) {
|
||
if (!entry || entry.name.startsWith('.')) continue;
|
||
const fullPath = path.join(dirPath, entry.name);
|
||
if (entry.isDirectory()) {
|
||
walkTemplatesDir(fullPath);
|
||
continue;
|
||
}
|
||
if (!entry.isFile()) continue;
|
||
const relativePath = path.relative(templatesDir, fullPath).split(path.sep).join('/');
|
||
if (relativePath) {
|
||
keys.add(relativePath);
|
||
}
|
||
}
|
||
};
|
||
walkTemplatesDir(templatesDir);
|
||
return keys;
|
||
};
|
||
|
||
const reconcileResourceOrder = (order: string[], allowedKeys: Set<string>): string[] => {
|
||
const seen = new Set<string>();
|
||
const nextOrder: string[] = [];
|
||
|
||
for (const key of order) {
|
||
if (!allowedKeys.has(key) || seen.has(key)) continue;
|
||
seen.add(key);
|
||
nextOrder.push(key);
|
||
}
|
||
|
||
const remaining = Array.from(allowedKeys).filter((key) => !seen.has(key));
|
||
remaining.sort((a, b) => a.localeCompare(b));
|
||
return [...remaining, ...nextOrder];
|
||
};
|
||
|
||
// Helper function to parse JSON body
|
||
const parseBody = (req: any): Promise<any> => {
|
||
return new Promise((resolve, reject) => {
|
||
let body = '';
|
||
req.on('data', (chunk: any) => body += chunk);
|
||
req.on('end', () => {
|
||
try {
|
||
resolve(body ? JSON.parse(body) : {});
|
||
} catch (e) {
|
||
reject(new Error('Invalid JSON in request body'));
|
||
}
|
||
});
|
||
req.on('error', reject);
|
||
});
|
||
};
|
||
|
||
// Helper function to send JSON response
|
||
const sendJSON = (res: any, statusCode: number, data: any) => {
|
||
res.statusCode = statusCode;
|
||
res.setHeader('Content-Type', 'application/json; charset=utf-8');
|
||
res.end(JSON.stringify(data));
|
||
};
|
||
|
||
const normalizePath = (filePath: string) => filePath.split(path.sep).join('/');
|
||
|
||
const isSafeSrcTargetPath = (targetPath: string) => {
|
||
return Boolean(targetPath)
|
||
&& !targetPath.includes('..')
|
||
&& !targetPath.startsWith('/')
|
||
&& !path.isAbsolute(targetPath);
|
||
};
|
||
|
||
const countFilesRecursive = (dirPath: string): number => {
|
||
if (!fs.existsSync(dirPath)) {
|
||
return 0;
|
||
}
|
||
|
||
let total = 0;
|
||
const entries = fs.readdirSync(dirPath, { withFileTypes: true });
|
||
for (const entry of entries) {
|
||
const entryPath = path.join(dirPath, entry.name);
|
||
if (entry.isDirectory()) {
|
||
total += countFilesRecursive(entryPath);
|
||
} else if (entry.isFile()) {
|
||
total += 1;
|
||
}
|
||
}
|
||
return total;
|
||
};
|
||
|
||
const readJsonFileIfExists = (filePath: string) => {
|
||
if (!fs.existsSync(filePath)) {
|
||
return null;
|
||
}
|
||
try {
|
||
return JSON.parse(fs.readFileSync(filePath, 'utf8'));
|
||
} catch (error) {
|
||
console.warn('[文件系统 API] 读取 JSON 失败:', filePath, error);
|
||
return null;
|
||
}
|
||
};
|
||
|
||
const createDefaultMakeMeta = (baseName: string) => ({
|
||
client_meta: {
|
||
background_color: { r: 0.96, g: 0.96, b: 0.96, a: 1 },
|
||
thumbnail_size: { width: 400, height: 300 },
|
||
render_coordinates: { x: 0, y: 0, width: 1280, height: 960 },
|
||
},
|
||
file_name: baseName,
|
||
developer_related_links: [],
|
||
exported_at: new Date().toISOString(),
|
||
});
|
||
|
||
const analyzeMakeAssets = (itemDir: string, targetPath: string) => {
|
||
const canvasFigPath = path.join(itemDir, 'canvas.fig');
|
||
const metaJsonPath = path.join(itemDir, 'meta.json');
|
||
const aiChatPath = path.join(itemDir, 'ai_chat.json');
|
||
const thumbnailPath = path.join(itemDir, 'thumbnail.png');
|
||
const manifestPath = path.join(itemDir, 'canvas.code-manifest.json');
|
||
const imagesDir = path.join(itemDir, 'images');
|
||
const rootIndexPath = path.join(itemDir, 'index.tsx');
|
||
const rootStylePath = path.join(itemDir, 'style.css');
|
||
const appTsxPath = path.join(itemDir, 'src', 'App.tsx');
|
||
const indexCssPath = path.join(itemDir, 'src', 'index.css');
|
||
const meta = readJsonFileIfExists(metaJsonPath);
|
||
const baseName = path.basename(targetPath) || 'project';
|
||
const rawFileName = typeof meta?.file_name === 'string' ? meta.file_name.trim() : '';
|
||
const normalizedFileName = rawFileName || baseName;
|
||
const imageCount = countFilesRecursive(imagesDir);
|
||
const driftReasons: string[] = [];
|
||
|
||
if (fs.existsSync(rootIndexPath) && fs.existsSync(appTsxPath)) {
|
||
const rootIndexStat = fs.statSync(rootIndexPath);
|
||
const appTsxStat = fs.statSync(appTsxPath);
|
||
if (rootIndexStat.mtimeMs > appTsxStat.mtimeMs + 1000) {
|
||
driftReasons.push('根目录 index.tsx 比 src/App.tsx 更新，Figma 导出壳子可能未同步最新页面逻辑。');
|
||
}
|
||
}
|
||
|
||
if (fs.existsSync(rootStylePath) && fs.existsSync(indexCssPath)) {
|
||
const rootStyleStat = fs.statSync(rootStylePath);
|
||
const indexCssStat = fs.statSync(indexCssPath);
|
||
if (rootStyleStat.mtimeMs > indexCssStat.mtimeMs + 1000) {
|
||
driftReasons.push('根目录 style.css 比 src/index.css 更新，Figma 导出壳子的样式可能未同步。');
|
||
}
|
||
}
|
||
|
||
return {
|
||
hasCanvasFig: fs.existsSync(canvasFigPath),
|
||
hasMetaJson: fs.existsSync(metaJsonPath),
|
||
hasAiChat: fs.existsSync(aiChatPath),
|
||
hasThumbnail: fs.existsSync(thumbnailPath),
|
||
hasManifest: fs.existsSync(manifestPath),
|
||
hasImagesDir: fs.existsSync(imagesDir),
|
||
imageCount,
|
||
hasMakeAssets: fs.existsSync(canvasFigPath),
|
||
lastExportedAt: typeof meta?.exported_at === 'string' ? meta.exported_at : null,
|
||
fileName: normalizedFileName.endsWith('.fig') ? normalizedFileName : `${normalizedFileName}.fig`,
|
||
hasDriftRisk: driftReasons.length > 0,
|
||
driftReasons,
|
||
itemDir,
|
||
canvasFigPath,
|
||
metaJsonPath,
|
||
aiChatPath,
|
||
thumbnailPath,
|
||
manifestPath,
|
||
imagesDir,
|
||
rootIndexPath,
|
||
rootStylePath,
|
||
appTsxPath,
|
||
indexCssPath,
|
||
meta,
|
||
};
|
||
};
|
||
|
||
const ensureMakeMeta = (itemDir: string, targetPath: string) => {
|
||
const snapshot = analyzeMakeAssets(itemDir, targetPath);
|
||
const baseName = path.basename(targetPath) || 'project';
|
||
const existingMeta = snapshot.meta && typeof snapshot.meta === 'object' ? snapshot.meta : {};
|
||
const nextMeta = {
|
||
...createDefaultMakeMeta(baseName),
|
||
...existingMeta,
|
||
client_meta: {
|
||
...createDefaultMakeMeta(baseName).client_meta,
|
||
...(existingMeta as any)?.client_meta,
|
||
},
|
||
developer_related_links: Array.isArray((existingMeta as any)?.developer_related_links)
|
||
? (existingMeta as any).developer_related_links
|
||
: [],
|
||
file_name: typeof (existingMeta as any)?.file_name === 'string' && (existingMeta as any).file_name.trim()
|
||
? (existingMeta as any).file_name.trim()
|
||
: baseName,
|
||
exported_at: new Date().toISOString(),
|
||
};
|
||
|
||
fs.writeFileSync(snapshot.metaJsonPath, JSON.stringify(nextMeta, null, 2), 'utf8');
|
||
return nextMeta;
|
||
};
|
||
|
||
const ensureMakeAiChat = (itemDir: string) => {
|
||
const aiChatPath = path.join(itemDir, 'ai_chat.json');
|
||
if (!fs.existsSync(aiChatPath)) {
|
||
fs.writeFileSync(aiChatPath, '{}\n', 'utf8');
|
||
}
|
||
};
|
||
|
||
const buildMakeExportPrompt = (targetPath: string) => {
|
||
const itemDir = path.join(projectRoot, 'src', targetPath);
|
||
const snapshot = analyzeMakeAssets(itemDir, targetPath);
|
||
const relativeItemDir = normalizePath(path.relative(projectRoot, itemDir));
|
||
const relativeCanvasFig = normalizePath(path.relative(projectRoot, snapshot.canvasFigPath));
|
||
const relativeMeta = normalizePath(path.relative(projectRoot, snapshot.metaJsonPath));
|
||
const relativeManifest = normalizePath(path.relative(projectRoot, snapshot.manifestPath));
|
||
const relativeAiChat = normalizePath(path.relative(projectRoot, snapshot.aiChatPath));
|
||
const relativeImagesDir = normalizePath(path.relative(projectRoot, snapshot.imagesDir));
|
||
const templateCanvasPath = 'scripts/templates/empty-canvas.fig';
|
||
const sceneLabel = snapshot.hasCanvasFig ? '场景 A（已有 Figma 导出资产）' : '场景 B（原生 Axhub 页面，需要补齐导出壳子）';
|
||
|
||
let prompt = `请将当前页面补齐为可导出的 Figma 资产结构，并确保最终可通过 \`/api/export-make?path=${targetPath}\` 下载产物 \`${snapshot.fileName}\`。\n\n`;
|
||
prompt += `请先阅读以下技能文档：\n`;
|
||
prompt += `- \`/skills/figma-make-exporter/SKILL.md\`\n`;
|
||
prompt += `- \`/skills/figma-make-project-converter/SKILL.md\`\n\n`;
|
||
prompt += `目标目录：\`${relativeItemDir}/\`\n`;
|
||
prompt += `当前判定：${sceneLabel}\n`;
|
||
prompt += `最终产物说明：接口最终下载的是原始 \`canvas.fig\`，文件名为 \`${snapshot.fileName}\`，不是 \`.make\` 压缩包。\n\n`;
|
||
prompt += `当前资产状态：\n`;
|
||
prompt += `- canvas.fig：${snapshot.hasCanvasFig ? '已存在' : '缺失'}\n`;
|
||
prompt += `- meta.json：${snapshot.hasMetaJson ? '已存在' : '缺失'}\n`;
|
||
prompt += `- ai_chat.json：${snapshot.hasAiChat ? '已存在' : '缺失'}\n`;
|
||
prompt += `- thumbnail.png：${snapshot.hasThumbnail ? '已存在' : '缺失'}\n`;
|
||
prompt += `- images/：${snapshot.hasImagesDir ? `已存在（${snapshot.imageCount} 个文件）` : '缺失'}\n\n`;
|
||
if (snapshot.hasDriftRisk) {
|
||
prompt += `当前检测到导出壳子可能未同步：\n`;
|
||
snapshot.driftReasons.forEach((reason: string) => {
|
||
prompt += `- ${reason}\n`;
|
||
});
|
||
prompt += `\n`;
|
||
}
|
||
prompt += `执行要求：\n`;
|
||
prompt += `1. 不要删除已有业务源码，也不要删除任何已存在的 Figma 原始资产（如 \`canvas.fig\`、\`meta.json\`、\`ai_chat.json\`、\`thumbnail.png\`、\`images/\`）。\n`;
|
||
prompt += `2. 先确保当前 Axhub 页面真实入口 \`index.tsx\` / \`style.css\` 的页面结果已经同步到导出壳子 \`src/App.tsx\` / \`src/index.css\` / \`src/components/**\`。\n`;
|
||
prompt += `3. 目录结构按固定职责维护：根目录 \`index.tsx\` 仅做 Axhub runtime adapter，\`src/App.tsx\` 仅做 Figma export shell，真实页面主体优先放在 \`src/components/**\` / \`src/styles/**\`。\n`;
|
||
prompt += `4. 同步时优先把 \`src/App.tsx\` 做成薄壳，尽量直接复用当前页面组件；不要再维护一份容易过时的旧页面副本。\n`;
|
||
prompt += `5. 如果 \`src/index.css\` 与根目录 \`style.css\` 都存在，优先复用或同步根目录样式来源，避免导出样式与当前页面不一致。\n`;
|
||
prompt += `6. 在 \`index.tsx\`、\`src/App.tsx\`、\`src/main.tsx\` 顶部补充职责注释，明确哪些文件只能做适配层/挂载层，防止后续继续漂移。\n`;
|
||
prompt += ` 若最终项目不符合这套固定职责结构，视为任务未完成，必须先重构到位再继续导出。\n`;
|
||
prompt += ` 导出前还必须同步 \`CODE_FILE.sourceCode\` 与 \`CODE_FILE.collaborativeSourceCode\`，再清理 \`canvas.fig\` 内部旧代码历史：移除过期 \`CODE_LIBRARY.chatMessages\` / \`chatCompressionState\`，清空旧 \`CODE_INSTANCE.codeSnapshot\` 预览缓存，并裁掉悬空的 \`CODE_COMPONENT\` 引用，避免 Figma Make 导入后恢复旧文件树。\n`;
|
||
if (snapshot.hasCanvasFig) {
|
||
prompt += `7. 直接复用已有 \`${relativeCanvasFig}\`，运行以下命令把当前源码回写进去：\n`;
|
||
prompt += ` \`node scripts/canvas-fig-sync.mjs pack --fig ${relativeCanvasFig} --from ${relativeItemDir} --prune-missing --sanitize-for-export\`\n`;
|
||
} else {
|
||
prompt += `7. 使用内置空白模板 \`${templateCanvasPath}\` 作为基座，在 \`${relativeCanvasFig}\` 生成新的 \`canvas.fig\`，然后运行：\n`;
|
||
prompt += ` \`node scripts/canvas-fig-sync.mjs pack --fig ${relativeCanvasFig} --from ${relativeItemDir} --prune-missing --sanitize-for-export\`\n`;
|
||
}
|
||
prompt += `8. 生成或更新 \`${relativeManifest}\`：\n`;
|
||
prompt += ` \`node scripts/canvas-fig-sync.mjs inspect --fig ${relativeCanvasFig} --manifest ${relativeManifest}\`\n`;
|
||
prompt += `9. 生成或更新 \`${relativeMeta}\`，至少包含 \`file_name\`、\`exported_at\`、\`client_meta\`、\`developer_related_links\`。其中 \`file_name\` 应与最终下载名一致，不要再写成 \`.make\`。\n`;
|
||
prompt += `10. 确保 \`${relativeAiChat}\` 至少是空 JSON 对象 \`{}\`。\n`;
|
||
prompt += `11. 如页面依赖图片资源，请把导出所需图片保留或同步到 \`${relativeImagesDir}/\`；不要随意改名已有 hash 文件。\n`;
|
||
prompt += `12. 如果当前目录缺少导出壳子（如 \`src/App.tsx\`、\`src/main.tsx\`、\`package.json\`、\`vite.config.ts\`、\`index.html\`），请按技能文档补齐到 Figma 兼容结构。\n\n`;
|
||
prompt += `验收要求：\n`;
|
||
prompt += `- \`node scripts/canvas-fig-sync.mjs inspect --fig ${relativeCanvasFig}\` 能成功执行\n`;
|
||
prompt += `- \`${relativeMeta}\` 中 \`exported_at\` 为最新时间\n`;
|
||
prompt += `- \`${relativeMeta}\` 中 \`file_name\` 对应最终下载文件名 \`${snapshot.fileName}\`\n`;
|
||
prompt += `- 导出壳子展示结果必须与当前页面一致，不能还是旧的 Figma 壳子内容\n`;
|
||
prompt += `- ` + '`index.tsx` / `src/App.tsx` / `src/main.tsx`' + ` 顶部存在职责注释，且符合固定目录结构\n`;
|
||
prompt += `- 再次访问 \`/api/export-make?path=${targetPath}&probe=1\` 时，返回 \`hasMakeAssets: true\`\n`;
|
||
return prompt;
|
||
};
|
||
|
||
server.middlewares.use('/api/prototype-admin/project-title', async (req: any, res: any) => {
|
||
if (req.method === 'GET') {
|
||
return sendJSON(res, 200, { title: readProjectTitle() });
|
||
}
|
||
if (req.method !== 'PATCH') {
|
||
return sendJSON(res, 405, { error: 'Method not allowed' });
|
||
}
|
||
|
||
try {
|
||
const body = await parseBody(req);
|
||
const rawTitle = typeof body?.title === 'string' ? body.title : '';
|
||
const title = rawTitle.trim();
|
||
if (!title) {
|
||
return sendJSON(res, 400, { error: 'title cannot be empty' });
|
||
}
|
||
if (/[\u0000-\u001F\u007F]/.test(title)) {
|
||
return sendJSON(res, 400, { error: 'title contains invalid control characters' });
|
||
}
|
||
|
||
const config = fs.existsSync(configPath)
|
||
? JSON.parse(fs.readFileSync(configPath, 'utf8'))
|
||
: {};
|
||
const nextConfig = {
|
||
...config,
|
||
projectInfo: {
|
||
...(config?.projectInfo || {}),
|
||
name: title,
|
||
},
|
||
};
|
||
fs.mkdirSync(path.dirname(configPath), { recursive: true });
|
||
fs.writeFileSync(configPath, JSON.stringify(nextConfig, null, 2), 'utf8');
|
||
return sendJSON(res, 200, { success: true, title });
|
||
} catch (e: any) {
|
||
return sendJSON(res, 500, { error: e?.message || 'Update project title failed' });
|
||
}
|
||
});
|
||
|
||
// ─── Skill Install API ──────────────────────────────────────────────
|
||
server.middlewares.use('/api/prototype-admin/install-skill', async (req: any, res: any) => {
|
||
if (req.method !== 'POST') {
|
||
return sendJSON(res, 405, { error: 'Method not allowed' });
|
||
}
|
||
|
||
try {
|
||
const body = await parseBody(req);
|
||
const skillId = typeof body?.skillId === 'string' ? body.skillId.trim() : '';
|
||
const client = typeof body?.client === 'string' ? body.client.trim() : '';
|
||
|
||
if (!skillId || !client) {
|
||
return sendJSON(res, 400, { error: 'skillId and client are required' });
|
||
}
|
||
|
||
const targetDir = getInstallSkillTargetDir(client);
|
||
if (!targetDir) {
|
||
return sendJSON(res, 400, {
|
||
error: 'not_supported',
|
||
message: `${client} 暂不支持自动安装技能`,
|
||
});
|
||
}
|
||
|
||
const sourceDir = path.join(projectRoot, 'skills', skillId);
|
||
if (!fs.existsSync(sourceDir)) {
|
||
return sendJSON(res, 404, { error: `Skill '${skillId}' not found at skills/${skillId}` });
|
||
}
|
||
|
||
const destDir = path.join(projectRoot, targetDir, skillId);
|
||
fs.mkdirSync(destDir, { recursive: true });
|
||
copyDirRecursive(sourceDir, destDir);
|
||
|
||
return sendJSON(res, 200, {
|
||
success: true,
|
||
skillId,
|
||
client,
|
||
installedTo: `${targetDir}/${skillId}`,
|
||
});
|
||
} catch (e: any) {
|
||
return sendJSON(res, 500, { error: e?.message || 'Install skill failed' });
|
||
}
|
||
});
|
||
|
||
server.middlewares.use('/api/prototype-admin/sidebar-tree/folder', async (req: any, res: any) => {
|
||
const tab = getTabFromRequest(req);
|
||
if (!tab) {
|
||
return sendJSON(res, 400, { error: 'Invalid tab, expected prototypes|components|docs|canvas' });
|
||
}
|
||
|
||
if (req.method !== 'POST') {
|
||
return sendJSON(res, 405, { error: 'Method not allowed' });
|
||
}
|
||
|
||
try {
|
||
const allowedItemKeys = resolveAllowedItemKeys(tab);
|
||
const storedTree = sidebarTreeStore.getTree(tab);
|
||
const sourceTree = storedTree.length > 0 ? storedTree : buildDefaultSidebarTree(allowedItemKeys);
|
||
const tree = reconcileSidebarTree(sourceTree, tab, allowedItemKeys);
|
||
|
||
const existingIds = collectSidebarTreeIds(tree);
|
||
const createdFolderId = createUniqueFolderNodeId(existingIds);
|
||
const title = createRootFolderTitle(tree);
|
||
const nextTree: SidebarTreeNode[] = [
|
||
{
|
||
id: createdFolderId,
|
||
kind: 'folder',
|
||
title,
|
||
children: [],
|
||
},
|
||
...tree,
|
||
];
|
||
|
||
sidebarTreeStore.setTree(tab, nextTree);
|
||
|
||
return sendJSON(res, 200, {
|
||
success: true,
|
||
tab,
|
||
version: SIDEBAR_TREE_VERSION,
|
||
createdFolderId,
|
||
tree: nextTree,
|
||
});
|
||
} catch (e: any) {
|
||
return sendJSON(res, 500, { error: e?.message || 'Create sidebar folder failed' });
|
||
}
|
||
});
|
||
|
||
server.middlewares.use('/api/prototype-admin/sidebar-tree', async (req: any, res: any) => {
|
||
const tab = getTabFromRequest(req);
|
||
if (!tab) {
|
||
return sendJSON(res, 400, { error: 'Invalid tab, expected prototypes|components|docs|canvas' });
|
||
}
|
||
|
||
if (req.method === 'GET') {
|
||
const allowedItemKeys = resolveAllowedItemKeys(tab);
|
||
const storedTree = sidebarTreeStore.getTree(tab);
|
||
const sourceTree = storedTree.length > 0 ? storedTree : buildDefaultSidebarTree(allowedItemKeys);
|
||
const tree = reconcileSidebarTree(sourceTree, tab, allowedItemKeys);
|
||
if (JSON.stringify(tree) !== JSON.stringify(storedTree)) {
|
||
sidebarTreeStore.setTree(tab, tree);
|
||
}
|
||
return sendJSON(res, 200, {
|
||
tab,
|
||
version: SIDEBAR_TREE_VERSION,
|
||
tree,
|
||
});
|
||
}
|
||
|
||
if (req.method !== 'PUT') {
|
||
return sendJSON(res, 405, { error: 'Method not allowed' });
|
||
}
|
||
|
||
try {
|
||
const body = await parseBody(req);
|
||
const allowedItemKeys = resolveAllowedItemKeys(tab);
|
||
const normalized = normalizeAndValidateSidebarTree(body?.tree, tab, allowedItemKeys);
|
||
if (!normalized.valid) {
|
||
return sendJSON(res, 400, { error: normalized.error });
|
||
}
|
||
sidebarTreeStore.setTree(tab, normalized.tree);
|
||
return sendJSON(res, 200, {
|
||
success: true,
|
||
tab,
|
||
version: SIDEBAR_TREE_VERSION,
|
||
tree: normalized.tree,
|
||
});
|
||
} catch (e: any) {
|
||
return sendJSON(res, 500, { error: e?.message || 'Save sidebar tree failed' });
|
||
}
|
||
});
|
||
|
||
server.middlewares.use('/api/prototype-admin/resource-order', async (req: any, res: any) => {
|
||
const type = getResourceOrderTypeFromRequest(req);
|
||
if (!type) {
|
||
return sendJSON(res, 400, { error: 'Invalid type, expected themes|data|templates' });
|
||
}
|
||
|
||
if (req.method === 'GET') {
|
||
try {
|
||
const allowedKeys = resolveAllowedResourceKeys(type);
|
||
const storedOrder = sidebarTreeStore.getResourceOrder(type);
|
||
const order = reconcileResourceOrder(storedOrder, allowedKeys);
|
||
if (JSON.stringify(order) !== JSON.stringify(storedOrder)) {
|
||
sidebarTreeStore.setResourceOrder(type, order);
|
||
}
|
||
return sendJSON(res, 200, {
|
||
type,
|
||
version: SIDEBAR_TREE_VERSION,
|
||
order,
|
||
});
|
||
} catch (e: any) {
|
||
return sendJSON(res, 500, { error: e?.message || 'Load resource order failed' });
|
||
}
|
||
}
|
||
|
||
if (req.method !== 'PUT') {
|
||
return sendJSON(res, 405, { error: 'Method not allowed' });
|
||
}
|
||
|
||
try {
|
||
const body = await parseBody(req);
|
||
if (!Array.isArray(body?.order)) {
|
||
return sendJSON(res, 400, { error: 'order must be an array' });
|
||
}
|
||
const requestedOrder = body.order
|
||
.filter((key: unknown): key is string => typeof key === 'string')
|
||
.map((key) => key.trim())
|
||
.filter(Boolean);
|
||
const allowedKeys = resolveAllowedResourceKeys(type);
|
||
const invalidKey = requestedOrder.find((key) => !allowedKeys.has(key));
|
||
if (invalidKey) {
|
||
return sendJSON(res, 400, { error: `Invalid resource key: ${invalidKey}` });
|
||
}
|
||
const order = reconcileResourceOrder(requestedOrder, allowedKeys);
|
||
sidebarTreeStore.setResourceOrder(type, order);
|
||
return sendJSON(res, 200, {
|
||
success: true,
|
||
type,
|
||
version: SIDEBAR_TREE_VERSION,
|
||
order,
|
||
});
|
||
} catch (e: any) {
|
||
return sendJSON(res, 500, { error: e?.message || 'Save resource order failed' });
|
||
}
|
||
});
|
||
|
||
const scanThemeReferences = (themeName: string) => {
|
||
const referenceDirs = [
|
||
path.join(projectRoot, 'src', 'components'),
|
||
path.join(projectRoot, 'src', 'prototypes'),
|
||
];
|
||
const allowedExt = new Set(['.ts', '.tsx', '.js', '.jsx', '.md', '.css']);
|
||
const needles = [
|
||
`themes/${themeName}/designToken.json`,
|
||
`themes/${themeName}/globals.css`,
|
||
];
|
||
const references = new Set<string>();
|
||
|
||
const walkDir = (dirPath: string) => {
|
||
if (!fs.existsSync(dirPath)) return;
|
||
const entries = fs.readdirSync(dirPath, { withFileTypes: true });
|
||
for (const entry of entries) {
|
||
const entryPath = path.join(dirPath, entry.name);
|
||
if (entry.isDirectory()) {
|
||
walkDir(entryPath);
|
||
continue;
|
||
}
|
||
|
||
const ext = path.extname(entry.name);
|
||
if (!allowedExt.has(ext)) continue;
|
||
|
||
const content = fs.readFileSync(entryPath, 'utf8');
|
||
if (needles.some(needle => content.includes(needle))) {
|
||
references.add(normalizePath(path.relative(projectRoot, entryPath)));
|
||
}
|
||
}
|
||
};
|
||
|
||
referenceDirs.forEach(walkDir);
|
||
|
||
return Array.from(references).sort();
|
||
};
|
||
|
||
const scanItemReferences = (itemType: 'components' | 'prototypes', itemName: string) => {
|
||
const referenceDirs = [
|
||
path.join(projectRoot, 'src', 'components'),
|
||
path.join(projectRoot, 'src', 'prototypes'),
|
||
];
|
||
const allowedExt = new Set(['.ts', '.tsx', '.js', '.jsx', '.md', '.css']);
|
||
const references = new Set<string>();
|
||
const normalizedItemName = String(itemName || '').trim();
|
||
const escapedName = normalizedItemName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
|
||
const nameRegex = new RegExp(`(?:^|[\\\\/])${escapedName}(?:$|[\\\\/'"\\s])`);
|
||
const targetDir = path.resolve(projectRoot, 'src', itemType, normalizedItemName);
|
||
|
||
const walkDir = (dirPath: string) => {
|
||
if (!fs.existsSync(dirPath)) return;
|
||
const entries = fs.readdirSync(dirPath, { withFileTypes: true });
|
||
for (const entry of entries) {
|
||
const entryPath = path.join(dirPath, entry.name);
|
||
if (entry.isDirectory()) {
|
||
if (path.resolve(entryPath) === targetDir) {
|
||
continue;
|
||
}
|
||
walkDir(entryPath);
|
||
continue;
|
||
}
|
||
|
||
const ext = path.extname(entry.name);
|
||
if (!allowedExt.has(ext)) continue;
|
||
|
||
const content = fs.readFileSync(entryPath, 'utf8');
|
||
if (nameRegex.test(content)) {
|
||
references.add(normalizePath(path.relative(projectRoot, entryPath)));
|
||
}
|
||
}
|
||
};
|
||
|
||
referenceDirs.forEach(walkDir);
|
||
|
||
return Array.from(references).sort();
|
||
};
|
||
|
||
// 递归复制目录
|
||
const copyDir = (src: string, dest: string) => {
|
||
fs.mkdirSync(dest, { recursive: true });
|
||
const entries = fs.readdirSync(src, { withFileTypes: true });
|
||
|
||
for (const entry of entries) {
|
||
const srcPath = path.join(src, entry.name);
|
||
const destPath = path.join(dest, entry.name);
|
||
|
||
if (entry.isDirectory()) {
|
||
copyDir(srcPath, destPath);
|
||
} else {
|
||
fs.copyFileSync(srcPath, destPath);
|
||
}
|
||
}
|
||
};
|
||
|
||
// ==================== /api/themes/check-references ====================
|
||
server.middlewares.use('/api/themes/check-references', async (req: any, res: any) => {
|
||
if (req.method !== 'POST') {
|
||
return sendJSON(res, 405, { error: 'Method not allowed' });
|
||
}
|
||
|
||
try {
|
||
const { themeName } = await parseBody(req);
|
||
if (!themeName || typeof themeName !== 'string') {
|
||
return sendJSON(res, 400, { error: 'Missing themeName parameter' });
|
||
}
|
||
|
||
const themeDir = path.join(projectRoot, 'src', 'themes', themeName);
|
||
if (!fs.existsSync(themeDir)) {
|
||
return sendJSON(res, 404, { error: 'Theme not found' });
|
||
}
|
||
|
||
const references = scanThemeReferences(themeName);
|
||
const designTokenPath = path.join(themeDir, 'designToken.json');
|
||
const globalsPath = path.join(themeDir, 'globals.css');
|
||
|
||
return sendJSON(res, 200, {
|
||
themeName,
|
||
references,
|
||
hasReferences: references.length > 0,
|
||
themeAssets: {
|
||
hasDesignToken: fs.existsSync(designTokenPath),
|
||
hasGlobals: fs.existsSync(globalsPath),
|
||
},
|
||
});
|
||
} catch (e: any) {
|
||
console.error('[文件系统 API] 检查主题引用失败:', e);
|
||
return sendJSON(res, 500, { error: e.message || 'Check references failed' });
|
||
}
|
||
});
|
||
|
||
server.middlewares.use('/api/themes/get-contents', async (req: any, res: any) => {
|
||
if (req.method !== 'POST') {
|
||
return sendJSON(res, 405, { error: 'Method not allowed' });
|
||
}
|
||
|
||
try {
|
||
const { themeName } = await parseBody(req);
|
||
if (!themeName || typeof themeName !== 'string') {
|
||
return sendJSON(res, 400, { error: 'Missing themeName parameter' });
|
||
}
|
||
|
||
const themeDir = path.join(projectRoot, 'src', 'themes', themeName);
|
||
if (!fs.existsSync(themeDir)) {
|
||
return sendJSON(res, 404, { error: 'Theme not found' });
|
||
}
|
||
|
||
const designTokenPath = path.join(themeDir, 'designToken.json');
|
||
const globalsPath = path.join(themeDir, 'globals.css');
|
||
const specPath = path.join(themeDir, 'DESIGN-SPEC.md');
|
||
|
||
return sendJSON(res, 200, {
|
||
themeName,
|
||
designToken: fs.existsSync(designTokenPath) ? fs.readFileSync(designTokenPath, 'utf8') : null,
|
||
globalsCss: fs.existsSync(globalsPath) ? fs.readFileSync(globalsPath, 'utf8') : null,
|
||
designSpec: fs.existsSync(specPath) ? fs.readFileSync(specPath, 'utf8') : null,
|
||
});
|
||
} catch (e: any) {
|
||
console.error('[文件系统 API] 获取主题内容失败:', e);
|
||
return sendJSON(res, 500, { error: e.message || 'Get theme contents failed' });
|
||
}
|
||
});
|
||
|
||
// ==================== /api/items/check-references ====================
|
||
server.middlewares.use('/api/items/check-references', async (req: any, res: any) => {
|
||
if (req.method !== 'POST') {
|
||
return sendJSON(res, 405, { error: 'Method not allowed' });
|
||
}
|
||
|
||
try {
|
||
const { itemType, itemName } = await parseBody(req);
|
||
if (!itemType || !itemName || typeof itemType !== 'string' || typeof itemName !== 'string') {
|
||
return sendJSON(res, 400, { error: 'Missing itemType or itemName parameter' });
|
||
}
|
||
|
||
if (itemType !== 'components' && itemType !== 'prototypes') {
|
||
return sendJSON(res, 400, { error: 'Invalid itemType' });
|
||
}
|
||
|
||
const itemDir = path.join(projectRoot, 'src', itemType, itemName);
|
||
if (!fs.existsSync(itemDir)) {
|
||
return sendJSON(res, 404, { error: 'Item not found' });
|
||
}
|
||
|
||
const references = scanItemReferences(itemType, itemName);
|
||
|
||
return sendJSON(res, 200, {
|
||
itemType,
|
||
itemName,
|
||
references,
|
||
hasReferences: references.length > 0,
|
||
});
|
||
} catch (e: any) {
|
||
console.error('[文件系统 API] 检查元素/页面引用失败:', e);
|
||
return sendJSON(res, 500, { error: e.message || 'Check references failed' });
|
||
}
|
||
});
|
||
|
||
// ==================== /api/delete ====================
|
||
server.middlewares.use('/api/delete', async (req: any, res: any) => {
|
||
if (req.method !== 'POST') {
|
||
return sendJSON(res, 405, { error: 'Method not allowed' });
|
||
}
|
||
|
||
try {
|
||
const { path: targetPath } = await parseBody(req);
|
||
|
||
if (!targetPath) {
|
||
return sendJSON(res, 400, { error: 'Missing path parameter' });
|
||
}
|
||
|
||
// 验证路径安全性
|
||
if (targetPath.includes('..') || targetPath.startsWith('/')) {
|
||
return sendJSON(res, 403, { error: 'Invalid path' });
|
||
}
|
||
|
||
const parts = String(targetPath).split('/').filter(Boolean);
|
||
const isElementsOrPages = parts.length === 2 && (parts[0] === 'components' || parts[0] === 'prototypes');
|
||
const deletePath = isElementsOrPages
|
||
? path.join(projectRoot, 'src', parts[0], parts[1])
|
||
: path.join(projectRoot, 'src', targetPath);
|
||
|
||
if (!fs.existsSync(deletePath)) {
|
||
return sendJSON(res, 404, { error: 'Directory not found' });
|
||
}
|
||
|
||
if (isElementsOrPages) {
|
||
fs.rmSync(deletePath, { recursive: true, force: true });
|
||
|
||
return sendJSON(res, 200, {
|
||
success: true,
|
||
deletedPaths: [targetPath],
|
||
});
|
||
}
|
||
|
||
// 删除目录
|
||
fs.rmSync(deletePath, { recursive: true, force: true });
|
||
|
||
return sendJSON(res, 200, { success: true });
|
||
} catch (e: any) {
|
||
console.error('[文件系统 API] 删除失败:', e);
|
||
return sendJSON(res, 500, { error: e.message || 'Delete failed' });
|
||
}
|
||
});
|
||
|
||
// ==================== /api/rename ====================
|
||
server.middlewares.use('/api/rename', async (req: any, res: any) => {
|
||
if (req.method !== 'POST') {
|
||
return sendJSON(res, 405, { error: 'Method not allowed' });
|
||
}
|
||
|
||
try {
|
||
const { path: targetPath, newName } = await parseBody(req);
|
||
|
||
if (!targetPath || !newName) {
|
||
return sendJSON(res, 400, { error: 'Missing path or newName parameter' });
|
||
}
|
||
|
||
// 验证路径安全性
|
||
if (targetPath.includes('..') || targetPath.startsWith('/')) {
|
||
return sendJSON(res, 403, { error: 'Invalid path' });
|
||
}
|
||
|
||
// 验证新名称格式
|
||
const trimmedNewName = String(newName).trim();
|
||
if (!trimmedNewName) {
|
||
return sendJSON(res, 400, { error: 'Invalid newName format' });
|
||
}
|
||
if (trimmedNewName === '.' || trimmedNewName === '..') {
|
||
return sendJSON(res, 400, { error: 'Invalid newName format' });
|
||
}
|
||
if (/[\r\n]/.test(trimmedNewName)) {
|
||
return sendJSON(res, 400, { error: 'Invalid newName format' });
|
||
}
|
||
if (trimmedNewName.includes('*/')) {
|
||
return sendJSON(res, 400, { error: 'Invalid newName format' });
|
||
}
|
||
if (/[/\\:*?"<>|]/.test(trimmedNewName)) {
|
||
return sendJSON(res, 400, { error: 'Invalid newName format' });
|
||
}
|
||
|
||
// 解析路径
|
||
const parts = String(targetPath).split('/').filter(Boolean);
|
||
if (parts.length !== 2 || (parts[0] !== 'components' && parts[0] !== 'prototypes')) {
|
||
return sendJSON(res, 400, { error: 'Invalid path format' });
|
||
}
|
||
|
||
const group = parts[0];
|
||
const itemName = parts[1];
|
||
const itemDir = path.join(projectRoot, 'src', group, itemName);
|
||
|
||
if (!fs.existsSync(itemDir)) {
|
||
return sendJSON(res, 404, { error: 'Directory not found' });
|
||
}
|
||
|
||
const indexFiles = ['index.tsx', 'index.ts', 'index.jsx', 'index.js'];
|
||
let indexFilePath: string | null = null;
|
||
for (const fileName of indexFiles) {
|
||
const filePath = path.join(itemDir, fileName);
|
||
if (fs.existsSync(filePath)) {
|
||
indexFilePath = filePath;
|
||
break;
|
||
}
|
||
}
|
||
|
||
if (!indexFilePath) {
|
||
return sendJSON(res, 404, { error: 'Entry file not found' });
|
||
}
|
||
|
||
const nameLineRegex = /(^\s*\*\s*@(?:name|displayName)\s+)(.+)$/m;
|
||
const content = fs.readFileSync(indexFilePath, 'utf8');
|
||
let updatedContent = content;
|
||
|
||
if (nameLineRegex.test(content)) {
|
||
updatedContent = content.replace(nameLineRegex, `$1${trimmedNewName}`);
|
||
} else {
|
||
updatedContent = `/**\n * @name ${trimmedNewName}\n */\n${content}`;
|
||
}
|
||
|
||
if (updatedContent !== content) {
|
||
fs.writeFileSync(indexFilePath, updatedContent, 'utf8');
|
||
}
|
||
|
||
sendJSON(res, 200, { success: true });
|
||
} catch (e: any) {
|
||
console.error('[文件系统 API] 重命名失败:', e);
|
||
sendJSON(res, 500, { error: e.message || 'Rename failed' });
|
||
}
|
||
});
|
||
|
||
// ==================== /api/upload ====================
|
||
server.middlewares.use('/api/upload', async (req: any, res: any) => {
|
||
if (req.method !== 'POST') {
|
||
return sendJSON(res, 405, { error: 'Method not allowed' });
|
||
}
|
||
|
||
try {
|
||
const form = formidable({
|
||
uploadDir: path.join(projectRoot, 'temp'),
|
||
keepExtensions: true,
|
||
multiples: true,
|
||
maxFileSize: 100 * 1024 * 1024, // 100MB
|
||
});
|
||
|
||
form.parse(req, async (err: any, fields: any, files: any) => {
|
||
if (err) {
|
||
console.error('[文件系统 API] 上传解析失败:', err);
|
||
return sendJSON(res, 500, { error: 'Upload parsing failed' });
|
||
}
|
||
|
||
try {
|
||
// 提取字段值（处理数组和单值）
|
||
const getFieldValue = (field: any) => Array.isArray(field) ? field[0] : field;
|
||
|
||
const uploadType = getFieldValue(fields.uploadType);
|
||
const targetType = getFieldValue(fields.targetType);
|
||
const uploadMode = getFieldValue(fields.uploadMode);
|
||
const folderNameField = getFieldValue(fields.folderName);
|
||
const targetTypeRequired = uploadType !== 'local_axure';
|
||
|
||
const normalizeFiles = (value: any) => {
|
||
if (!value) return [];
|
||
return Array.isArray(value) ? value : [value];
|
||
};
|
||
|
||
let fileList = normalizeFiles(files.files);
|
||
if (fileList.length === 0) fileList = normalizeFiles(files.file);
|
||
if (fileList.length === 0 && fields.file) {
|
||
fileList = normalizeFiles(fields.file);
|
||
}
|
||
|
||
const isFolderUpload = uploadMode === 'folder' || fileList.length > 1;
|
||
|
||
console.log('[文件系统 API] 原始文件对象:', {
|
||
hasFilesFile: !!files.file,
|
||
hasFilesFiles: !!files.files,
|
||
hasFieldsFile: !!fields.file,
|
||
fileCount: fileList.length,
|
||
uploadMode,
|
||
isFolderUpload,
|
||
});
|
||
|
||
console.log('[文件系统 API] 接收到的参数:', {
|
||
uploadType,
|
||
targetType,
|
||
hasFile: fileList.length > 0,
|
||
fileInfo: fileList.length > 0 ? { filepath: fileList[0]?.filepath, originalFilename: fileList[0]?.originalFilename } : null,
|
||
fieldsKeys: Object.keys(fields),
|
||
filesKeys: Object.keys(files)
|
||
});
|
||
|
||
if (!fileList.length || !uploadType || (targetTypeRequired && !targetType)) {
|
||
console.error('[文件系统 API] 缺少必需参数:', {
|
||
hasFile: fileList.length > 0,
|
||
uploadType,
|
||
targetType,
|
||
fileType: fileList.length > 0 ? typeof fileList[0] : 'undefined'
|
||
});
|
||
return sendJSON(res, 400, {
|
||
error: 'Missing required parameters',
|
||
details: {
|
||
hasFile: fileList.length > 0,
|
||
hasUploadType: !!uploadType,
|
||
hasTargetType: !!targetType,
|
||
targetTypeRequired
|
||
}
|
||
});
|
||
}
|
||
|
||
if (
|
||
targetTypeRequired
|
||
&& !SUPPORTED_UPLOAD_TARGET_TYPES.includes(String(targetType) as (typeof SUPPORTED_UPLOAD_TARGET_TYPES)[number])
|
||
) {
|
||
return sendJSON(res, 400, {
|
||
error: `Invalid targetType: ${targetType}. Supported targetType: ${SUPPORTED_UPLOAD_TARGET_TYPES.join(', ')}`
|
||
});
|
||
}
|
||
|
||
if (targetType === 'themes' && !THEME_IMPORT_SUPPORTED_UPLOAD_TYPES.has(String(uploadType))) {
|
||
return sendJSON(res, 400, {
|
||
error: `uploadType=${uploadType} 暂不支持 targetType=themes。当前支持: ${Array.from(THEME_IMPORT_SUPPORTED_UPLOAD_TYPES).join(', ')}`
|
||
});
|
||
}
|
||
|
||
const primaryFile = fileList[0];
|
||
const tempFilePath = primaryFile?.filepath || primaryFile?.path || primaryFile?.tempFilePath;
|
||
const originalFilename = primaryFile?.originalFilename || primaryFile?.name || primaryFile?.filename || 'upload.zip';
|
||
|
||
console.log('[文件系统 API] 文件信息:', {
|
||
tempFilePath,
|
||
originalFilename,
|
||
fileCount: fileList.length,
|
||
isFolderUpload,
|
||
});
|
||
|
||
if (uploadType === 'figma_make') {
|
||
if (isFolderUpload) {
|
||
return sendJSON(res, 400, { error: 'figma_make 仅支持上传 Figma 原始导出的 ZIP 工程包，请不要上传文件夹' });
|
||
}
|
||
if (!String(originalFilename).toLowerCase().endsWith('.zip')) {
|
||
return sendJSON(res, 400, { error: 'figma_make 仅支持 ZIP 文件，请上传 Figma 原始导出的 ZIP 工程包' });
|
||
}
|
||
}
|
||
|
||
if (!isFolderUpload) {
|
||
if (!tempFilePath || !fs.existsSync(tempFilePath)) {
|
||
return sendJSON(res, 500, { error: '临时文件不存在' });
|
||
}
|
||
|
||
if (fs.statSync(tempFilePath).size === 0) {
|
||
return sendJSON(res, 500, { error: '上传的文件为空' });
|
||
}
|
||
} else {
|
||
const missingFile = fileList.find((file: any) => !file?.filepath || !fs.existsSync(file.filepath));
|
||
if (missingFile) {
|
||
return sendJSON(res, 500, { error: '上传的文件夹存在缺失文件，请重试' });
|
||
}
|
||
}
|
||
|
||
const relativePaths = normalizeFiles(fields.relativePaths).map((value: any) => String(value));
|
||
const derivedRootName = deriveRootFolderName(relativePaths);
|
||
|
||
// AI 辅助类型：local_axure（解压到 temp 并返回 Prompt）
|
||
if (uploadType === 'local_axure') {
|
||
if (isFolderUpload) {
|
||
return sendJSON(res, 400, { error: 'local_axure 暂不支持文件夹上传，请使用 ZIP 文件' });
|
||
}
|
||
try {
|
||
const scriptPath = path.join(projectRoot, 'scripts', 'local-axure-extract.mjs');
|
||
const commandResult = runCommandSync({
|
||
command: nodeCommand,
|
||
args: [scriptPath, tempFilePath, originalFilename],
|
||
cwd: projectRoot,
|
||
});
|
||
|
||
if (commandResult.status !== 0) {
|
||
const details = [commandResult.stderr, commandResult.stdout]
|
||
.filter(Boolean)
|
||
.join('\n')
|
||
.trim();
|
||
throw new Error(details || 'local-axure-extract failed');
|
||
}
|
||
|
||
const rawOutput = commandResult.stdout.trim();
|
||
|
||
const lastLine = rawOutput.split('\n').filter(Boolean).slice(-1)[0] || rawOutput;
|
||
const extracted = JSON.parse(lastLine) as { extractDir: string; contentDir?: string };
|
||
const filePath = extracted.contentDir || extracted.extractDir;
|
||
|
||
// 清理临时 zip
|
||
fs.unlinkSync(tempFilePath);
|
||
|
||
const isThemeImport = targetType === 'themes';
|
||
const skillDocs = isThemeImport
|
||
? ['/skills/local-axure-workflow/SKILL.md', ...THEME_IMPORT_SUB_SKILL_DOCS]
|
||
: ['/skills/local-axure-workflow/SKILL.md'];
|
||
const targetHint = targetType ? `\n\n建议输出目录：\`src/${targetType}\`` : '';
|
||
const prompt = isThemeImport
|
||
? `本地 Axure ZIP 已上传并解压完成。\n\n解压目录：\`${filePath}\`\n\n请阅读技能文档：\n${formatReferenceList(skillDocs)}\n\n目标：导入主题并生成主题/文档/数据相关资产。\n\n建议输出目录：\n- \`src/themes/<theme-key>/\`\n- \`src/docs/\`\n- \`src/database/\`\n\n开始执行前：先根据 skill 的用户交互指南用简短中文回复用户，确认需求（主题范围/是否需要文档与数据/是否允许优化）。\n\n请按技能文档流程，从解压目录中提取并生成主题 token、设计规范、项目文档与数据模型。`
|
||
: `本地 Axure ZIP 已上传并解压完成。\n\n解压目录：\`${filePath}\`\n\n请阅读技能文档：\n${formatReferenceList(skillDocs)}${targetHint}\n\n开始执行前：先根据 skill 的用户交互指南用简短中文回复用户，确认需求（目标范围/输出类型/是否允许优化等）。\n\n请按技能文档流程，从解压目录中提取主题/数据/文档并还原页面/元素。`;
|
||
|
||
return sendJSON(res, 200, {
|
||
success: true,
|
||
uploadType,
|
||
filePath,
|
||
prompt,
|
||
message: '文件已解压，请复制 Prompt 交给 AI 处理'
|
||
});
|
||
} catch (e: any) {
|
||
console.error('[文件系统 API] local_axure 解压失败:', e);
|
||
return sendJSON(res, 500, { error: `解压失败: ${e.message}` });
|
||
}
|
||
}
|
||
|
||
let folderUploadContext: {
|
||
tempExtractDir: string;
|
||
inferred: { entryCount: number; hasRootFolder: boolean; rootFolderName: string };
|
||
fallbackName: string;
|
||
} | null = null;
|
||
|
||
if (isFolderUpload) {
|
||
try {
|
||
const tempExtractDir = path.join(projectRoot, 'temp', `folder-upload-${Date.now()}`);
|
||
fs.mkdirSync(tempExtractDir, { recursive: true });
|
||
|
||
const fallbackSource = folderNameField || derivedRootName || `upload-${Date.now()}`;
|
||
const fallbackName = truncateName(sanitizeFolderName(fallbackSource), 60) || `upload-${Date.now()}`;
|
||
|
||
fileList.forEach((file: any, index: number) => {
|
||
const sourcePath = file?.filepath || file?.path || file?.tempFilePath;
|
||
if (!sourcePath || !fs.existsSync(sourcePath)) return;
|
||
|
||
const rawRelativePath = relativePaths[index] || file?.originalFilename || file?.name || `file-${index}`;
|
||
const safeRelativePath = sanitizeRelativePath(String(rawRelativePath));
|
||
if (!safeRelativePath || hasIgnoredEntry(safeRelativePath)) {
|
||
fs.unlinkSync(sourcePath);
|
||
return;
|
||
}
|
||
|
||
const destPath = path.join(tempExtractDir, safeRelativePath);
|
||
fs.mkdirSync(path.dirname(destPath), { recursive: true });
|
||
fs.copyFileSync(sourcePath, destPath);
|
||
fs.unlinkSync(sourcePath);
|
||
});
|
||
|
||
const inferred = inferExtractedRootFolder(tempExtractDir);
|
||
if (inferred.entryCount === 0) {
|
||
return sendJSON(res, 500, { error: '上传的文件夹为空' });
|
||
}
|
||
|
||
folderUploadContext = {
|
||
tempExtractDir,
|
||
inferred,
|
||
fallbackName
|
||
};
|
||
} catch (e: any) {
|
||
console.error('[文件系统 API] 文件夹处理失败:', e);
|
||
return sendJSON(res, 500, { error: `文件夹处理失败: ${e.message || '未知错误'}` });
|
||
}
|
||
}
|
||
|
||
// 直接处理类型：make, axhub, google_stitch
|
||
if (['make', 'axhub', 'google_stitch'].includes(uploadType)) {
|
||
try {
|
||
// 解压到临时目录（先解压再分析目录结构，避免依赖 ZIP 条目解析）
|
||
const tempExtractDir = isFolderUpload
|
||
? folderUploadContext!.tempExtractDir
|
||
: path.join(projectRoot, 'temp', `extract-${Date.now()}`);
|
||
|
||
if (!isFolderUpload) {
|
||
fs.mkdirSync(tempExtractDir, { recursive: true });
|
||
await extractZip(tempFilePath, { dir: tempExtractDir });
|
||
}
|
||
|
||
const inferred = isFolderUpload
|
||
? folderUploadContext!.inferred
|
||
: inferExtractedRootFolder(tempExtractDir);
|
||
if (inferred.entryCount === 0) {
|
||
throw new Error('ZIP 文件为空');
|
||
}
|
||
|
||
const extractedRootFolderName = inferred.rootFolderName;
|
||
const hasRootFolder = inferred.hasRootFolder;
|
||
|
||
const basename = isFolderUpload
|
||
? folderUploadContext!.fallbackName
|
||
: path.basename(originalFilename, path.extname(originalFilename));
|
||
const fallbackFolderName = truncateName(sanitizeFolderName(basename), 60);
|
||
const safeFallbackFolderName = fallbackFolderName || `upload-${Date.now()}`;
|
||
const targetFolderName = hasRootFolder
|
||
? truncateName(extractedRootFolderName, 60)
|
||
: safeFallbackFolderName;
|
||
|
||
const targetBaseDir = path.join(projectRoot, 'src', targetType);
|
||
const targetDir = path.join(targetBaseDir, targetFolderName);
|
||
const resolvedTargetBase = path.resolve(targetBaseDir);
|
||
const resolvedTargetDir = path.resolve(targetDir);
|
||
|
||
// 防止覆盖整个 prototypes/components 目录或越界写入
|
||
if (resolvedTargetDir === resolvedTargetBase || !resolvedTargetDir.startsWith(resolvedTargetBase + path.sep)) {
|
||
throw new Error('目标目录不安全，已阻止解压');
|
||
}
|
||
|
||
console.log('[文件系统 API] ZIP 结构分析:', {
|
||
hasRootFolder,
|
||
rootFolderName: extractedRootFolderName,
|
||
targetDir,
|
||
entriesCount: inferred.entryCount
|
||
});
|
||
|
||
// 如果目标目录已存在，直接删除（覆盖）
|
||
if (fs.existsSync(targetDir)) {
|
||
fs.rmSync(targetDir, { recursive: true, force: true });
|
||
}
|
||
|
||
// 🔧 Windows 兼容性修复：等待杀毒软件释放文件
|
||
// 在 Windows 上，解压后杀毒软件（如 Windows Defender）会立即扫描新文件
|
||
// 导致文件被短暂锁定，此时执行 rename 会触发 EPERM 错误
|
||
// 延迟 500ms 让杀毒软件完成扫描，大幅降低权限错误的概率
|
||
await new Promise(resolve => setTimeout(resolve, 500));
|
||
|
||
// 移动到目标目录（使用复制+删除方式作为 fallback，避免 Windows 权限问题）
|
||
if (hasRootFolder) {
|
||
// 有根目录：移动根目录
|
||
const extractedRoot = path.join(tempExtractDir, extractedRootFolderName);
|
||
if (fs.existsSync(extractedRoot)) {
|
||
try {
|
||
// 优先尝试 rename（快速路径，毫秒级完成）
|
||
// rename 只修改文件系统元数据，不移动实际数据，性能最优
|
||
fs.renameSync(extractedRoot, targetDir);
|
||
} catch (renameError: any) {
|
||
// rename 失败则使用复制+删除（兼容路径，秒级完成）
|
||
// 虽然慢，但能处理跨驱动器、权限问题等 rename 无法处理的情况
|
||
console.warn('[文件系统] rename 失败，使用复制方式:', renameError.message);
|
||
copyDirRecursive(extractedRoot, targetDir);
|
||
fs.rmSync(extractedRoot, { recursive: true, force: true });
|
||
}
|
||
} else {
|
||
throw new Error('解压后找不到根目录');
|
||
}
|
||
} else {
|
||
// 没有根目录：直接移动整个解压目录
|
||
try {
|
||
// 优先尝试 rename（快速路径）
|
||
fs.renameSync(tempExtractDir, targetDir);
|
||
} catch (renameError: any) {
|
||
// rename 失败则使用复制+删除（兼容路径）
|
||
console.warn('[文件系统] rename 失败，使用复制方式:', renameError.message);
|
||
copyDirRecursive(tempExtractDir, targetDir);
|
||
fs.rmSync(tempExtractDir, { recursive: true, force: true });
|
||
}
|
||
}
|
||
|
||
// 清理临时文件
|
||
if (fs.existsSync(tempExtractDir)) {
|
||
fs.rmSync(tempExtractDir, { recursive: true, force: true });
|
||
}
|
||
if (!isFolderUpload) {
|
||
fs.unlinkSync(tempFilePath);
|
||
}
|
||
|
||
// 根据类型执行转换脚本
|
||
if (uploadType === 'axhub') {
|
||
// Chrome 扩展：执行转换脚本
|
||
const scriptPath = path.join(projectRoot, 'scripts', 'chrome-export-converter.mjs');
|
||
void runCommand({
|
||
command: nodeCommand,
|
||
args: [scriptPath, targetDir, targetFolderName],
|
||
cwd: projectRoot,
|
||
capture: true,
|
||
}).then((result) => {
|
||
if (result.code !== 0) {
|
||
console.error('[Chrome 转换] 执行失败:', result.stderr || result.stdout || `exit=${result.code}`);
|
||
} else {
|
||
console.log('[Chrome 转换] 完成:', result.stdout);
|
||
}
|
||
if (result.stderr) console.error('[Chrome 转换] 错误:', result.stderr);
|
||
}).catch((error: any) => {
|
||
console.error('[Chrome 转换] 执行失败:', error);
|
||
});
|
||
} else if (uploadType === 'google_stitch') {
|
||
const scriptPath = path.join(projectRoot, 'scripts', 'stitch-converter.mjs');
|
||
const commandResult = runCommandSync({
|
||
command: nodeCommand,
|
||
args: [scriptPath, targetDir, targetFolderName],
|
||
cwd: projectRoot,
|
||
});
|
||
|
||
if (commandResult.status !== 0) {
|
||
throw new Error(commandResult.stderr || commandResult.stdout || `stitch-converter exit=${commandResult.status}`);
|
||
}
|
||
|
||
const output = commandResult.stdout.trim();
|
||
const lastLine = output.split('\n').filter(Boolean).slice(-1)[0] || output;
|
||
let stitchResult: {
|
||
success?: boolean;
|
||
requiresAi?: boolean;
|
||
prompt?: string | null;
|
||
reasons?: string[];
|
||
} = {};
|
||
|
||
try {
|
||
stitchResult = JSON.parse(lastLine);
|
||
} catch (parseError: any) {
|
||
throw new Error(`stitch-converter 返回结果无法解析: ${parseError.message}`);
|
||
}
|
||
|
||
const requiresAi = stitchResult.requiresAi === true;
|
||
return sendJSON(res, 200, {
|
||
success: true,
|
||
message: requiresAi
|
||
? '页面已导入完成，可先预览基础效果。部分细节还可继续优化，建议交给 AI 完成。'
|
||
: '上传并解压成功',
|
||
folderName: targetFolderName,
|
||
path: `${targetType}/${targetFolderName}`,
|
||
hint: requiresAi
|
||
? '复制提示词后，可继续完善交互与动态内容'
|
||
: '如果页面无法预览，让 AI 处理即可',
|
||
requiresAi,
|
||
prompt: stitchResult.prompt || undefined,
|
||
reasons: Array.isArray(stitchResult.reasons) ? stitchResult.reasons : [],
|
||
});
|
||
}
|
||
|
||
return sendJSON(res, 200, {
|
||
success: true,
|
||
message: '上传并解压成功',
|
||
folderName: targetFolderName,
|
||
path: `${targetType}/${targetFolderName}`,
|
||
hint: '如果页面无法预览，让 AI 处理即可'
|
||
});
|
||
} catch (e: any) {
|
||
console.error('[文件系统 API] 解压失败:', e);
|
||
if (e?.code === 'ENAMETOOLONG') {
|
||
return sendJSON(res, 500, {
|
||
error:
|
||
'解压失败：ZIP 内部路径过长（超出系统限制）。请解压后上传文件夹，或缩短文件名后重试。',
|
||
});
|
||
}
|
||
return sendJSON(res, 500, { error: `解压失败: ${e.message}` });
|
||
}
|
||
}
|
||
|
||
// AI 处理类型：v0, google_aistudio, figma_make
|
||
if (['v0', 'google_aistudio', 'figma_make'].includes(uploadType)) {
|
||
try {
|
||
// 解压到 temp 目录
|
||
const timestamp = Date.now();
|
||
const basename = isFolderUpload
|
||
? (folderUploadContext?.fallbackName || folderNameField || derivedRootName || `upload-${timestamp}`)
|
||
: path.basename(originalFilename, path.extname(originalFilename));
|
||
const extractDirName = `${uploadType}-${truncateName(sanitizeFolderName(basename), 40)}-${timestamp}`;
|
||
const extractDir = isFolderUpload
|
||
? (folderUploadContext!.inferred.hasRootFolder
|
||
? path.join(folderUploadContext!.tempExtractDir, folderUploadContext!.inferred.rootFolderName)
|
||
: folderUploadContext!.tempExtractDir)
|
||
: path.join(projectRoot, 'temp', extractDirName);
|
||
|
||
if (!isFolderUpload) {
|
||
fs.mkdirSync(extractDir, { recursive: true });
|
||
await extractZip(tempFilePath, { dir: extractDir });
|
||
fs.unlinkSync(tempFilePath);
|
||
}
|
||
|
||
const pageName = basename
|
||
.replace(/[^a-z0-9-]/gi, '-')
|
||
.replace(/-+/g, '-')
|
||
.replace(/^-|-$/g, '')
|
||
.toLowerCase();
|
||
const isThemeTarget = targetType === 'themes';
|
||
|
||
const converterConfigs: Record<string, {
|
||
label: string;
|
||
scriptFile: string;
|
||
tasksFileName: string;
|
||
themeTasksFileName: string;
|
||
}> = {
|
||
v0: {
|
||
label: 'V0',
|
||
scriptFile: 'v0-converter.mjs',
|
||
tasksFileName: '.v0-tasks.md',
|
||
themeTasksFileName: '.v0-theme-tasks.md',
|
||
},
|
||
google_aistudio: {
|
||
label: 'AI Studio',
|
||
scriptFile: 'ai-studio-converter.mjs',
|
||
tasksFileName: '.ai-studio-tasks.md',
|
||
themeTasksFileName: '.ai-studio-theme-tasks.md',
|
||
},
|
||
figma_make: {
|
||
label: 'Figma Make',
|
||
scriptFile: 'figma-make-converter.mjs',
|
||
tasksFileName: '.figma-make-tasks.md',
|
||
themeTasksFileName: '.figma-make-theme-tasks.md',
|
||
},
|
||
};
|
||
|
||
const converterConfig = converterConfigs[String(uploadType)];
|
||
if (!converterConfig) {
|
||
throw new Error(`未知的上传类型: ${uploadType}`);
|
||
}
|
||
|
||
const scriptPath = path.join(projectRoot, 'scripts', converterConfig.scriptFile);
|
||
const tasksFileName = isThemeTarget ? converterConfig.themeTasksFileName : converterConfig.tasksFileName;
|
||
const commandArgs = [scriptPath, extractDir, pageName, '--target-type', String(targetType)];
|
||
|
||
console.log(`[${converterConfig.label} 转换] 执行预处理脚本:`, `node ${commandArgs.join(' ')}`);
|
||
|
||
try {
|
||
const commandResult = runCommandSync({
|
||
command: nodeCommand,
|
||
args: commandArgs,
|
||
cwd: projectRoot,
|
||
});
|
||
|
||
if (commandResult.status !== 0) {
|
||
throw new Error(commandResult.stderr || commandResult.stdout || `exit=${commandResult.status}`);
|
||
}
|
||
const output = commandResult.stdout;
|
||
|
||
console.log(`[${converterConfig.label} 转换] 执行成功:`, output);
|
||
|
||
const tasksFilePath = path.join(projectRoot, 'src', targetType, pageName, tasksFileName);
|
||
if (!fs.existsSync(tasksFilePath)) {
|
||
throw new Error(`任务文档生成失败: ${tasksFileName}`);
|
||
}
|
||
|
||
const tasksFileRelPath = `src/${targetType}/${pageName}/${tasksFileName}`;
|
||
const prompt = isThemeTarget
|
||
? `${converterConfig.label} 项目已上传并预处理完成（主题模式）。\n\n请仔细阅读并执行主题任务清单：\n- ${tasksFileRelPath}\n\n然后请基于该任务清单和技能文档，进行主题拆分（输出到 \`src/themes/${pageName}/\`、\`src/docs/\`、\`src/database/\`）。`
|
||
: `${converterConfig.label} 项目已上传并预处理完成。\n\n请仔细阅读并执行以下任务清单：\n- ${tasksFileRelPath}\n\n然后根据该任务清单和技能文档，完成具体的转换工作。`;
|
||
|
||
return sendJSON(res, 200, {
|
||
success: true,
|
||
uploadType,
|
||
pageName,
|
||
tasksFile: tasksFileRelPath,
|
||
prompt,
|
||
message: isThemeTarget ? '主题预处理完成，请查看任务文档' : '预处理完成，请查看任务文档'
|
||
});
|
||
} catch (scriptError: any) {
|
||
console.error(`[${converterConfig.label} 转换] 执行失败:`, scriptError);
|
||
|
||
const pageDir = path.join(projectRoot, 'src', targetType, pageName);
|
||
if (fs.existsSync(pageDir)) {
|
||
fs.rmSync(pageDir, { recursive: true, force: true });
|
||
}
|
||
|
||
return sendJSON(res, 500, {
|
||
error: `预处理脚本执行失败: ${scriptError.message}`,
|
||
details: scriptError.stderr || scriptError.stdout || scriptError.message
|
||
});
|
||
}
|
||
} catch (e: any) {
|
||
console.error('[文件系统 API] 解压失败:', e);
|
||
if (e?.code === 'ENAMETOOLONG') {
|
||
return sendJSON(res, 500, {
|
||
error:
|
||
'解压失败：ZIP 内部路径过长（超出系统限制）。请解压后上传文件夹，或缩短文件名后重试。',
|
||
});
|
||
}
|
||
return sendJSON(res, 500, { error: `解压失败: ${e.message}` });
|
||
}
|
||
}
|
||
|
||
// 未知类型
|
||
return sendJSON(res, 400, { error: `不支持的上传类型: ${uploadType}` });
|
||
} catch (e: any) {
|
||
console.error('[文件系统 API] 文件处理失败:', e);
|
||
return sendJSON(res, 500, { error: e.message || 'File processing failed' });
|
||
}
|
||
});
|
||
} catch (e: any) {
|
||
console.error('[文件系统 API] 上传失败:', e);
|
||
sendJSON(res, 500, { error: e.message || 'Upload failed' });
|
||
}
|
||
});
|
||
|
||
// ==================== /api/upload-screenshots ====================
|
||
server.middlewares.use('/api/upload-screenshots', async (req: any, res: any) => {
|
||
if (req.method !== 'POST') {
|
||
return sendJSON(res, 405, { error: 'Method not allowed' });
|
||
}
|
||
|
||
try {
|
||
const form = formidable({
|
||
uploadDir: path.join(projectRoot, 'temp'),
|
||
keepExtensions: true,
|
||
maxFileSize: 20 * 1024 * 1024, // 20MB per image
|
||
multiples: true,
|
||
});
|
||
|
||
form.parse(req, async (err: any, fields: any, files: any) => {
|
||
if (err) {
|
||
console.error('[文件系统 API] 截图上传解析失败:', err);
|
||
return sendJSON(res, 500, { error: 'Upload parsing failed' });
|
||
}
|
||
|
||
try {
|
||
const getFieldValue = (field: any) => Array.isArray(field) ? field[0] : field;
|
||
|
||
const rawBatchId = getFieldValue(fields.batchId);
|
||
const targetType = getFieldValue(fields.targetType);
|
||
const batchId = (typeof rawBatchId === 'string' ? rawBatchId : '')
|
||
.trim()
|
||
.replace(/[^a-z0-9_-]/gi, '')
|
||
.slice(0, 64);
|
||
|
||
if (
|
||
targetType
|
||
&& !SUPPORTED_UPLOAD_TARGET_TYPES.includes(String(targetType) as (typeof SUPPORTED_UPLOAD_TARGET_TYPES)[number])
|
||
) {
|
||
return sendJSON(res, 400, {
|
||
error: `Invalid targetType: ${targetType}. Supported targetType: ${SUPPORTED_UPLOAD_TARGET_TYPES.join(', ')}`
|
||
});
|
||
}
|
||
|
||
const isThemeTarget = targetType === 'themes';
|
||
|
||
const resolvedBatchId = batchId || `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
|
||
const screenshotsDir = path.join(projectRoot, 'temp', 'screenshots', resolvedBatchId);
|
||
fs.mkdirSync(screenshotsDir, { recursive: true });
|
||
|
||
const fileInput = (files.file ?? files.files) as any;
|
||
const fileList = Array.isArray(fileInput) ? fileInput : (fileInput ? [fileInput] : []);
|
||
|
||
if (fileList.length === 0) {
|
||
return sendJSON(res, 400, { error: 'Missing file' });
|
||
}
|
||
|
||
const savedNames: string[] = [];
|
||
|
||
for (const file of fileList) {
|
||
const tempFilePath = file.filepath || file.path || file.tempFilePath;
|
||
const originalFilename = file.originalFilename || file.name || file.filename || 'screenshot';
|
||
|
||
if (!tempFilePath || !fs.existsSync(tempFilePath)) {
|
||
continue;
|
||
}
|
||
|
||
let safeName = path.basename(originalFilename).trim();
|
||
safeName = safeName.replace(/[^\w.\- ]+/g, '-').replace(/\s+/g, '-');
|
||
if (!safeName) safeName = 'screenshot';
|
||
|
||
const ext = path.extname(safeName) || path.extname(originalFilename) || path.extname(tempFilePath) || '';
|
||
const base = ext ? safeName.slice(0, -ext.length) : safeName;
|
||
|
||
let candidate = `${base}${ext}`;
|
||
let counter = 2;
|
||
while (fs.existsSync(path.join(screenshotsDir, candidate))) {
|
||
candidate = `${base}-${counter}${ext}`;
|
||
counter += 1;
|
||
}
|
||
|
||
const destPath = path.join(screenshotsDir, candidate);
|
||
moveFileWithFallback(tempFilePath, destPath);
|
||
savedNames.push(candidate);
|
||
}
|
||
|
||
const entries = fs.readdirSync(screenshotsDir, { withFileTypes: true });
|
||
const filePaths = entries
|
||
.filter(entry => entry.isFile())
|
||
.map(entry => normalizePath(path.join('temp', 'screenshots', resolvedBatchId, entry.name)))
|
||
.sort((a, b) => a.localeCompare(b));
|
||
|
||
const docs = isThemeTarget
|
||
? [
|
||
'/skills/screen-to-code/SKILL.md',
|
||
'/skills/screen-to-code/screenshot-collection.md',
|
||
...THEME_IMPORT_SUB_SKILL_DOCS,
|
||
]
|
||
: [
|
||
'/skills/screen-to-code/SKILL.md',
|
||
'/skills/screen-to-code/screenshot-collection.md',
|
||
];
|
||
|
||
const prompt = isThemeTarget
|
||
? `**系统指令**：你将作为UI/UX 设计架构师 × 前端工程师（复合型），协助用户「基于截图导入并创建主题」。
|
||
|
||
请严格按以下技能文档执行：
|
||
${formatReferenceList(docs)}
|
||
|
||
截图清单（已上传到工作区）：
|
||
${filePaths.map(p => `- \`${p}\``).join('\n')}
|
||
|
||
先和用户确认 \`theme-key\` 与输出范围（是否需要文档/数据），然后基于截图生成主题 token、设计规范文档与主题示例入口，必要时补充 \`src/docs/\` 与 \`src/database/\`。`
|
||
: `**系统指令**：你将作为UI/UX 设计架构师 × 前端工程师（复合型），协助用户「基于截图导入并创建页面/元素」。
|
||
|
||
请严格按以下技能文档执行（必须完整跑完 Phase 0 → 5）：
|
||
${formatReferenceList(docs)}
|
||
|
||
截图清单（已上传到工作区）：
|
||
${filePaths.map(p => `- \`${p}\``).join('\n')}
|
||
|
||
从 Phase 0 开始：先确认要生成页面还是元素、目标 name（kebab-case）、是否允许优化设计/交互；然后按文档产出抽象 JSON → 代码蓝图 → 再生成代码。`;
|
||
|
||
return sendJSON(res, 200, {
|
||
success: true,
|
||
batchId: resolvedBatchId,
|
||
files: filePaths,
|
||
saved: savedNames,
|
||
prompt,
|
||
message: filePaths.length > 1 ? `已上传 ${filePaths.length} 张截图` : '已上传 1 张截图',
|
||
});
|
||
} catch (e: any) {
|
||
console.error('[文件系统 API] 截图处理失败:', e);
|
||
return sendJSON(res, 500, { error: e.message || 'File processing failed' });
|
||
}
|
||
});
|
||
} catch (e: any) {
|
||
console.error('[文件系统 API] 截图上传失败:', e);
|
||
return sendJSON(res, 500, { error: e.message || 'Upload failed' });
|
||
}
|
||
});
|
||
|
||
// ==================== /api/export-make ====================
|
||
server.middlewares.use('/api/export-make', async (req: any, res: any) => {
|
||
if (req.method !== 'GET') {
|
||
return sendJSON(res, 405, { error: 'Method not allowed' });
|
||
}
|
||
|
||
try {
|
||
const url = new URL(req.url, `http://${req.headers.host}`);
|
||
const targetPath = (url.searchParams.get('path') || '').trim();
|
||
|
||
if (!targetPath) {
|
||
return sendJSON(res, 400, { error: 'Missing path parameter' });
|
||
}
|
||
|
||
if (!isSafeSrcTargetPath(targetPath)) {
|
||
return sendJSON(res, 403, { error: 'Invalid path' });
|
||
}
|
||
|
||
const itemDir = path.join(projectRoot, 'src', targetPath);
|
||
if (!fs.existsSync(itemDir) || !fs.statSync(itemDir).isDirectory()) {
|
||
return sendJSON(res, 404, { error: 'Directory not found' });
|
||
}
|
||
|
||
const probe = url.searchParams.get('probe') === '1';
|
||
const promptMode = url.searchParams.get('prompt') === '1';
|
||
const snapshot = analyzeMakeAssets(itemDir, targetPath);
|
||
|
||
if (probe) {
|
||
return sendJSON(res, 200, {
|
||
ok: true,
|
||
path: targetPath,
|
||
hasMakeAssets: snapshot.hasMakeAssets,
|
||
lastExportedAt: snapshot.lastExportedAt,
|
||
fileName: snapshot.fileName,
|
||
hasCanvasFig: snapshot.hasCanvasFig,
|
||
hasMetaJson: snapshot.hasMetaJson,
|
||
hasAiChat: snapshot.hasAiChat,
|
||
hasThumbnail: snapshot.hasThumbnail,
|
||
hasManifest: snapshot.hasManifest,
|
||
hasImagesDir: snapshot.hasImagesDir,
|
||
imageCount: snapshot.imageCount,
|
||
hasDriftRisk: snapshot.hasDriftRisk,
|
||
driftReasons: snapshot.driftReasons,
|
||
});
|
||
}
|
||
|
||
if (promptMode) {
|
||
return sendJSON(res, 200, {
|
||
ok: true,
|
||
path: targetPath,
|
||
hasMakeAssets: snapshot.hasMakeAssets,
|
||
fileName: snapshot.fileName,
|
||
hasDriftRisk: snapshot.hasDriftRisk,
|
||
driftReasons: snapshot.driftReasons,
|
||
prompt: buildMakeExportPrompt(targetPath),
|
||
});
|
||
}
|
||
|
||
if (!snapshot.hasCanvasFig) {
|
||
return sendJSON(res, 409, {
|
||
error: '当前页面尚未生成 .fig 导出所需资产，请先复制 Prompt 让 AI 补齐。',
|
||
hasMakeAssets: false,
|
||
fileName: snapshot.fileName,
|
||
hasDriftRisk: snapshot.hasDriftRisk,
|
||
driftReasons: snapshot.driftReasons,
|
||
prompt: buildMakeExportPrompt(targetPath),
|
||
});
|
||
}
|
||
|
||
if (snapshot.hasDriftRisk) {
|
||
return sendJSON(res, 409, {
|
||
error: '检测到当前页面与 Figma 导出壳子可能未同步，请先按 Prompt 同步后再导出 .fig。',
|
||
hasMakeAssets: true,
|
||
fileName: snapshot.fileName,
|
||
hasDriftRisk: true,
|
||
driftReasons: snapshot.driftReasons,
|
||
prompt: buildMakeExportPrompt(targetPath),
|
||
});
|
||
}
|
||
|
||
const scriptPath = path.join(projectRoot, 'scripts', 'canvas-fig-sync.mjs');
|
||
|
||
const packResult = runCommandSync({
|
||
command: nodeCommand,
|
||
args: [
|
||
scriptPath,
|
||
'pack',
|
||
'--fig',
|
||
snapshot.canvasFigPath,
|
||
'--from',
|
||
itemDir,
|
||
'--prune-missing',
|
||
'--sanitize-for-export',
|
||
'--manifest',
|
||
snapshot.manifestPath,
|
||
],
|
||
cwd: projectRoot,
|
||
});
|
||
if (packResult.status !== 0) {
|
||
throw new Error(packResult.stderr || packResult.stdout || `pack failed: exit=${packResult.status}`);
|
||
}
|
||
|
||
const inspectResult = runCommandSync({
|
||
command: nodeCommand,
|
||
args: [
|
||
scriptPath,
|
||
'inspect',
|
||
'--fig',
|
||
snapshot.canvasFigPath,
|
||
'--manifest',
|
||
snapshot.manifestPath,
|
||
],
|
||
cwd: projectRoot,
|
||
});
|
||
if (inspectResult.status !== 0) {
|
||
throw new Error(inspectResult.stderr || inspectResult.stdout || `inspect failed: exit=${inspectResult.status}`);
|
||
}
|
||
|
||
const meta = ensureMakeMeta(itemDir, targetPath);
|
||
ensureMakeAiChat(itemDir);
|
||
|
||
const fileNameBase = typeof meta?.file_name === 'string' && meta.file_name.trim()
|
||
? meta.file_name.trim()
|
||
: path.basename(targetPath);
|
||
const downloadFileName = fileNameBase.endsWith('.fig') ? fileNameBase : `${fileNameBase}.fig`;
|
||
|
||
res.setHeader('Content-Type', 'application/octet-stream');
|
||
res.setHeader('Content-Disposition', buildAttachmentContentDisposition(downloadFileName));
|
||
|
||
try {
|
||
const stream = fs.createReadStream(snapshot.canvasFigPath);
|
||
stream.on('error', (streamError: any) => {
|
||
console.error('[文件系统 API] export-make fig 读取失败:', streamError);
|
||
if (!res.headersSent) {
|
||
sendJSON(res, 500, { error: `读取 .fig 失败: ${streamError.message}` });
|
||
} else {
|
||
res.end();
|
||
}
|
||
});
|
||
|
||
await new Promise<void>((resolve, reject) => {
|
||
stream.on('end', resolve);
|
||
stream.on('error', reject);
|
||
res.on('close', resolve);
|
||
stream.pipe(res);
|
||
});
|
||
} catch (streamError: any) {
|
||
console.error('[文件系统 API] export-make fig 输出失败:', streamError);
|
||
if (!res.headersSent) {
|
||
return sendJSON(res, 500, { error: `输出 .fig 失败: ${streamError.message}` });
|
||
}
|
||
}
|
||
} catch (e: any) {
|
||
console.error('[文件系统 API] export-make 失败:', e);
|
||
if (!res.headersSent) {
|
||
sendJSON(res, 500, { error: e.message || 'Export make failed' });
|
||
}
|
||
}
|
||
});
|
||
|
||
// ==================== /api/zip ====================
|
||
server.middlewares.use('/api/zip', async (req: any, res: any) => {
|
||
if (req.method !== 'GET') {
|
||
return sendJSON(res, 405, { error: 'Method not allowed' });
|
||
}
|
||
|
||
try {
|
||
const url = new URL(req.url, `http://${req.headers.host}`);
|
||
const targetPath = url.searchParams.get('path'); // e.g., 'prototypes/antd-demo'
|
||
|
||
if (!targetPath) {
|
||
return sendJSON(res, 400, { error: 'Missing path parameter' });
|
||
}
|
||
|
||
// 验证路径安全性
|
||
if (targetPath.includes('..') || targetPath.startsWith('/')) {
|
||
return sendJSON(res, 403, { error: 'Invalid path' });
|
||
}
|
||
|
||
const srcDir = path.join(projectRoot, 'src', targetPath);
|
||
|
||
if (!fs.existsSync(srcDir)) {
|
||
return sendJSON(res, 404, { error: 'Directory not found' });
|
||
}
|
||
|
||
const probe = url.searchParams.get('probe') === '1';
|
||
const fileName = `${path.basename(targetPath)}.zip`;
|
||
if (probe) {
|
||
return sendJSON(res, 200, {
|
||
ok: true,
|
||
fileName,
|
||
path: targetPath,
|
||
});
|
||
}
|
||
|
||
res.setHeader('Content-Type', 'application/zip');
|
||
res.setHeader('Content-Disposition', buildAttachmentContentDisposition(fileName));
|
||
|
||
// 使用 streaming 方式创建 ZIP（避免在内存中构建整个 zip buffer）
|
||
try {
|
||
const archive = new (archiver as any)('zip', { zlib: { level: 9 } });
|
||
|
||
archive.on('warning', (warning: any) => {
|
||
console.warn('[文件系统 API] ZIP warning:', warning);
|
||
});
|
||
|
||
archive.on('error', (zipError: any) => {
|
||
console.error('[文件系统 API] ZIP 创建失败:', zipError);
|
||
if (!res.headersSent) {
|
||
sendJSON(res, 500, { error: `创建 ZIP 失败: ${zipError.message}` });
|
||
} else {
|
||
res.end();
|
||
}
|
||
});
|
||
|
||
archive.pipe(res);
|
||
archive.directory(srcDir, false);
|
||
|
||
await new Promise<void>((resolve) => {
|
||
res.on('close', resolve);
|
||
res.on('finish', resolve);
|
||
archive.on('error', resolve);
|
||
archive.finalize();
|
||
});
|
||
} catch (zipError: any) {
|
||
console.error('[文件系统 API] ZIP 创建失败:', zipError);
|
||
if (!res.headersSent) {
|
||
return sendJSON(res, 500, { error: `创建 ZIP 失败: ${zipError.message}` });
|
||
}
|
||
}
|
||
} catch (e: any) {
|
||
console.error('[文件系统 API] zip 失败:', e);
|
||
if (!res.headersSent) {
|
||
sendJSON(res, 500, { error: e.message || 'Zip failed' });
|
||
}
|
||
}
|
||
});
|
||
|
||
// ==================== /api/copy ====================
|
||
server.middlewares.use('/api/copy', async (req: any, res: any) => {
|
||
if (req.method !== 'POST') {
|
||
return sendJSON(res, 405, { error: 'Method not allowed' });
|
||
}
|
||
|
||
try {
|
||
const { sourcePath, targetPath } = await parseBody(req);
|
||
|
||
if (!sourcePath || !targetPath) {
|
||
return sendJSON(res, 400, { error: 'Missing sourcePath or targetPath parameter' });
|
||
}
|
||
|
||
// 验证路径安全性
|
||
if (sourcePath.includes('..') || targetPath.includes('..')) {
|
||
return sendJSON(res, 403, { error: 'Invalid path' });
|
||
}
|
||
|
||
// 验证目标路径不包含中文字符
|
||
const targetFolderName = path.basename(targetPath);
|
||
if (/[\u4e00-\u9fa5]/.test(targetFolderName)) {
|
||
return sendJSON(res, 400, { error: 'Target folder name cannot contain Chinese characters' });
|
||
}
|
||
|
||
// sourcePath 和 targetPath 格式: src/components/xxx 或 src/prototypes/xxx
|
||
const sourceDir = path.join(projectRoot, sourcePath);
|
||
const targetDir = path.join(projectRoot, targetPath);
|
||
|
||
if (!fs.existsSync(sourceDir)) {
|
||
return sendJSON(res, 404, { error: 'Source directory not found' });
|
||
}
|
||
|
||
if (fs.existsSync(targetDir)) {
|
||
return sendJSON(res, 409, { error: 'Target directory already exists' });
|
||
}
|
||
|
||
// 复制目录
|
||
copyDir(sourceDir, targetDir);
|
||
|
||
// 更新副本的 @name 注释
|
||
const indexFiles = ['index.tsx', 'index.ts', 'index.jsx', 'index.js'];
|
||
let indexFilePath: string | null = null;
|
||
|
||
for (const fileName of indexFiles) {
|
||
const filePath = path.join(targetDir, fileName);
|
||
if (fs.existsSync(filePath)) {
|
||
indexFilePath = filePath;
|
||
break;
|
||
}
|
||
}
|
||
|
||
if (indexFilePath) {
|
||
try {
|
||
let content = fs.readFileSync(indexFilePath, 'utf8');
|
||
|
||
// 提取文件夹名中的副本编号
|
||
const copyMatch = targetFolderName.match(/-copy(\d*)$/);
|
||
let copySuffix = '副本';
|
||
if (copyMatch) {
|
||
const copyNum = copyMatch[1];
|
||
copySuffix = copyNum ? `副本${copyNum}` : '副本';
|
||
}
|
||
|
||
// 更新 @name 注释
|
||
content = content.replace(
|
||
/(@name\s+)([^\n]+)/,
|
||
(match, prefix, name) => {
|
||
// 如果名称已经包含"副本"，先移除
|
||
const cleanName = name.replace(/\s*副本\d*\s*$/, '').trim();
|
||
return `${prefix}${cleanName} ${copySuffix}`;
|
||
}
|
||
);
|
||
|
||
fs.writeFileSync(indexFilePath, content, 'utf8');
|
||
} catch (e) {
|
||
console.error('[文件系统 API] 更新 @name 注释失败:', e);
|
||
// 不影响主流程，继续执行
|
||
}
|
||
}
|
||
|
||
sendJSON(res, 200, { success: true });
|
||
} catch (e: any) {
|
||
console.error('[文件系统 API] 复制失败:', e);
|
||
sendJSON(res, 500, { error: e.message || 'Copy failed' });
|
||
}
|
||
});
|
||
}
|
||
};
|
||
}
|