@yinuo-ngm/server 1.0.20 → 1.0.22

package/lib/routes/node-runtime.routes.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = nodeRuntimeRoutes;
+function toNodeRuntimeConfig(input) {
+    return input;
+}
+function toNodeRuntimeRecordDto(record) {
+    return {
+        id: record.id,
+        name: record.name,
+        version: record.version,
+        platform: String(record.platform),
+        arch: String(record.arch),
+        rootDir: record.rootDir,
+        nodePath: record.nodePath,
+        npmPath: record.npmPath,
+        npxPath: record.npxPath,
+        pnpmPath: record.pnpmPath,
+        yarnPath: record.yarnPath,
+        npmCliPath: record.npmCliPath,
+        npxCliPath: record.npxCliPath,
+        source: record.source,
+    };
+}
+function toResolvedNodeRuntimeDto(runtime) {
+    return {
+        type: runtime.type,
+        name: runtime.name,
+        version: runtime.version,
+        packageManager: runtime.packageManager,
+        rootDir: runtime.rootDir,
+        binDir: runtime.binDir,
+        nodePath: runtime.nodePath,
+        npmPath: runtime.npmPath,
+        npxPath: runtime.npxPath,
+        pnpmPath: runtime.pnpmPath,
+        yarnPath: runtime.yarnPath,
+        npmCliPath: runtime.npmCliPath,
+        npxCliPath: runtime.npxCliPath,
+        env: runtime.env,
+        source: runtime.source,
+    };
+}
+function toNodeRuntimeTestResultDto(result) {
+    return {
+        ok: result.ok,
+        nodeVersion: result.nodeVersion,
+        npmVersion: result.npmVersion,
+        nodePath: result.nodePath,
+        npmLaunchCommand: result.npmLaunchCommand,
+        errors: result.errors,
+    };
+}
+async function nodeRuntimeRoutes(fastify) {
+    fastify.get("/", async () => {
+        const runtimes = await fastify.core.nodeRuntime.listRuntimes();
+        return runtimes.map(toNodeRuntimeRecordDto);
+    });
+    fastify.post("/resolve", async (req) => {
+        const body = req.body;
+        const runtime = await fastify.core.nodeRuntime.resolveRuntime(toNodeRuntimeConfig(body?.runtime));
+        return toResolvedNodeRuntimeDto(runtime);
+    });
+    fastify.post("/test", async (req) => {
+        const body = req.body;
+        const result = await fastify.core.nodeRuntime.testRuntime(toNodeRuntimeConfig(body?.runtime) || { type: "system" });
+        return toNodeRuntimeTestResultDto(result);
+    });
+}

package/lib/routes/project.routes.js

@@ -37,10 +37,84 @@ exports.default = projectRoutes;
 const errors_1 = require("@yinuo-ngm/errors");
 const path = __importStar(require("path"));
 const editor_1 = require("../common/editor");
+function toProjectAssetSourceSvnDto(source) {
+    return {
+        kind: source.kind,
+        id: source.id,
+        label: source.label,
+        url: source.url,
+        localDir: source.localDir,
+        mode: source.mode,
+    };
+}
+function toProjectAssetsDto(assets) {
+    if (!assets)
+        return undefined;
+    return {
+        iconsSvn: assets.iconsSvn ? toProjectAssetSourceSvnDto(assets.iconsSvn) : undefined,
+        cutImageSvn: assets.cutImageSvn ? toProjectAssetSourceSvnDto(assets.cutImageSvn) : undefined,
+    };
+}
+function toProjectDto(project) {
+    return {
+        id: project.id,
+        name: project.name,
+        description: project.description,
+        root: project.root,
+        createdAt: project.createdAt,
+        updatedAt: project.updatedAt,
+        scripts: project.scripts,
+        packageManager: project.packageManager,
+        runtime: project.runtime,
+        nodeVersion: project.nodeVersion,
+        framework: project.framework,
+        env: project.env,
+        isFavorite: project.isFavorite,
+        lastOpened: project.lastOpened,
+        repoUrl: project.repoUrl,
+        repoPageUrl: project.repoPageUrl,
+        assets: toProjectAssetsDto(project.assets),
+    };
+}
+function toDetectResultDto(detect) {
+    if (!detect)
+        return undefined;
+    return {
+        framework: detect.framework,
+        hasPackageJson: detect.hasPackageJson,
+        scripts: detect.scripts,
+        scriptsCount: detect.scriptsCount,
+        recommendedScript: detect.recommendedScript,
+        lockFile: detect.lockFile,
+        hasGit: detect.hasGit,
+        hasMakefile: detect.hasMakefile,
+        hasDockerCompose: detect.hasDockerCompose,
+    };
+}
+function toImportCheckResultDto(result) {
+    return {
+        ok: result.ok,
+        root: result.root,
+        code: result.code,
+        reason: result.reason,
+        detect: toDetectResultDto(result.detect),
+        warnings: result.warnings,
+    };
+}
+function toCheckRootResultDto(result) {
+    return {
+        ok: result.ok,
+        root: result.root,
+        exists: result.exists,
+        isDir: result.isDir,
+        alreadyRegistered: result.alreadyRegistered,
+        message: result.message,
+    };
+}
 async function projectRoutes(fastify) {
     fastify.get("/list", async () => {
         const projects = await fastify.core.project.list();
-        return projects;
+        return projects.map(toProjectDto);
     });
     fastify.post("/update/:id", async (req, reply) => {
         const { id } = req.params;
@@ -54,8 +128,9 @@ async function projectRoutes(fastify) {
                 ...(body.name !== undefined ? { name: body.name } : {}),
                 ...(body.env !== undefined ? { env: body.env } : {}),
                 ...(body.scripts !== undefined ? { scripts: body.scripts } : {}),
+                ...(body.runtime !== undefined ? { runtime: body.runtime } : {}),
             });
-            return updated;
+            return toProjectDto(updated);
         }
         catch (err) {
             if (err instanceof Error) {
@@ -67,7 +142,31 @@ async function projectRoutes(fastify) {
     fastify.get("/getInfo/:id", async (req) => {
         const { id } = req.params;
         const project = await fastify.core.project.get(id);
-        return project;
+        return toProjectDto(project);
+    });
+    async function updateProjectRuntime(projectId, body) {
+        const updated = await fastify.core.project.update(projectId, {
+            runtime: body.runtime,
+        });
+        return toProjectDto(updated);
+    }
+    fastify.patch("/:id/runtime", async (req) => {
+        const { id } = req.params;
+        const body = req.body;
+        return updateProjectRuntime(id, body);
+    });
+    fastify.post("/:id/runtime", async (req) => {
+        const { id } = req.params;
+        const body = req.body;
+        return updateProjectRuntime(id, body);
+    });
+    fastify.post("/:id/runtime/test", async (req) => {
+        const { id } = req.params;
+        const project = await fastify.core.project.get(id);
+        const runtimeConfig = project.runtime ?? (project.nodeVersion
+            ? { type: "managed", version: project.nodeVersion, packageManager: project.packageManager === "pnpm" || project.packageManager === "yarn" ? project.packageManager : "npm" }
+            : { type: "system", packageManager: project.packageManager === "pnpm" || project.packageManager === "yarn" ? project.packageManager : "npm" });
+        return await fastify.core.nodeRuntime.testRuntime(runtimeConfig);
     });
     fastify.delete("/delete/:id", async (req) => {
         const { id } = req.params;
@@ -76,7 +175,8 @@ async function projectRoutes(fastify) {
     });
     fastify.post("/check", async (req) => {
         const body = req.body;
-        return fastify.core.project.checkRoot(body.rootPath);
+        const result = await fastify.core.project.checkRoot(body.rootPath);
+        return toCheckRootResultDto(result);
     });
     fastify.post("/detect", async (req) => {
         const body = req.body;
@@ -85,13 +185,16 @@ async function projectRoutes(fastify) {
         return {
             framework: meta.framework ?? "unknown",
             hasPackageJson: !!meta.scripts && Object.keys(meta.scripts).length > 0,
-            scripts: meta.scripts ?? {},
+            scripts: Object.keys(meta.scripts ?? {}),
+            scriptsCount: Object.keys(meta.scripts ?? {}).length,
             recommendedScript: meta.scripts?.dev
                 ? "dev"
                 : meta.scripts?.start
                     ? "start"
                     : Object.keys(meta.scripts ?? {})[0],
             hasGit: meta.hasGit ?? false,
+            hasMakefile: meta.hasMakefile ?? false,
+            hasDockerCompose: meta.hasDockerCompose ?? false,
         };
     });
     fastify.post("/import", async (req) => {
@@ -109,7 +212,8 @@ async function projectRoutes(fastify) {
     });
     fastify.post("/checkImport", async (req) => {
         const body = req.body;
-        return fastify.core.project.checkImport(body.root);
+        const result = await fastify.core.project.checkImport(body.root);
+        return toImportCheckResultDto(result);
     });
     fastify.post("/create", async (req) => {
         const body = req.body;
@@ -127,12 +231,12 @@ async function projectRoutes(fastify) {
             return { message: "isFavorite must be boolean" };
         }
         const updated = await fastify.core.project.setFavorite(id, body.isFavorite);
-        return updated;
+        return toProjectDto(updated);
     });
     fastify.post("/favorite/:id/toggle", async (req) => {
         const { id } = req.params;
         const updated = await fastify.core.project.toggleFavorite(id);
-        return updated;
+        return toProjectDto(updated);
     });
     fastify.post("/lastOpened/:id", async (req) => {
         const { id } = req.params;
@@ -141,7 +245,7 @@ async function projectRoutes(fastify) {
             throw new errors_1.GlobalError(errors_1.GlobalErrorCodes.INVALID_TIMESTAMP, "timestamp must be a number");
         }
         const updated = await fastify.core.project.setLastOpened(id, body.timestamp);
-        return updated;
+        return toProjectDto(updated);
     });
     fastify.post("/rename/:id", async (req) => {
         const { id } = req.params;
@@ -150,12 +254,12 @@ async function projectRoutes(fastify) {
             throw new errors_1.CoreError(errors_1.CoreErrorCodes.INVALID_NAME, "name must be a non-empty string");
         }
         const updated = await fastify.core.project.rename(id, body.name.trim());
-        return updated;
+        return toProjectDto(updated);
     });
     fastify.post("/refreshScripts/:id", async (req) => {
         const { id } = req.params;
         const updated = await fastify.core.project.refreshScripts(id);
-        return updated;
+        return toProjectDto(updated);
     });
     fastify.post("/edit/:id", async (req) => {
         const { id } = req.params;
@@ -168,7 +272,7 @@ async function projectRoutes(fastify) {
             description: body.description?.trim(),
             repoPageUrl: body.repoPageUrl?.trim(),
         });
-        return updated;
+        return toProjectDto(updated);
     });
     fastify.post("/updateAssets/:id", async (req) => {
         const { id } = req.params;
@@ -178,7 +282,7 @@ async function projectRoutes(fastify) {
             throw new errors_1.GlobalError(errors_1.GlobalErrorCodes.BAD_REQUEST, "参数错误，assets.iconsSvn 是必需的");
         }
         const updated = await fastify.core.project.updateAssets(id, assets);
-        return updated;
+        return toProjectDto(updated);
     });
     fastify.post("/openInEditor/:id", async (req) => {
         try {

package/lib/routes/sprite/sprite-browse.routes.d.ts

@@ -0,0 +1,2 @@
+import type { FastifyInstance } from "fastify";
+export default function spriteBrowseRoutes(fastify: FastifyInstance): Promise<void>;

package/lib/routes/sprite/sprite-browse.routes.js

@@ -0,0 +1,137 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = spriteBrowseRoutes;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const errors_1 = require("@yinuo-ngm/errors");
+const sprite_quick_utils_1 = require("./sprite-quick.utils");
+const SKIP = new Set([
+    ".svn",
+    ".git",
+    ".hg",
+    ".DS_Store",
+    "__MACOSX",
+    "Thumbs.db",
+]);
+function safeJoin(root, sub) {
+    const resolved = node_path_1.default.resolve(root, sub);
+    const rootResolved = node_path_1.default.resolve(root);
+    if (!resolved.startsWith(rootResolved)) {
+        throw new errors_1.GlobalError(errors_1.GlobalErrorCodes.BAD_REQUEST, "INVALID_PATH");
+    }
+    return resolved;
+}
+function listDir(root) {
+    if (!node_fs_1.default.existsSync(root))
+        return [];
+    return node_fs_1.default
+        .readdirSync(root, { withFileTypes: true })
+        .filter(d => !SKIP.has(d.name) && !d.name.startsWith("."))
+        .map(d => ({
+        name: d.name,
+        kind: (d.isDirectory() ? "dir" : "file"),
+        ext: d.isDirectory() ? undefined : node_path_1.default.extname(d.name).toLowerCase(),
+    })).sort((a, b) => {
+        if (a.kind === b.kind) {
+            return a.name.localeCompare(b.name, "zh-Hans-CN", { numeric: true });
+        }
+        return a.kind === "dir" ? -1 : 1;
+    });
+}
+function countFiles(dir) {
+    if (!node_fs_1.default.existsSync(dir) || !node_fs_1.default.statSync(dir).isDirectory())
+        return 0;
+    return node_fs_1.default.readdirSync(dir, { withFileTypes: true }).filter(d => d.isFile()).length;
+}
+function toBrowseEntriesDto(root, entries) {
+    return { root, entries };
+}
+function toBrowseFilesDto(root, dir, entries) {
+    return { root, dir, entries };
+}
+async function spriteBrowseRoutes(fastify) {
+    fastify.get("/icons/groups/:projectId", async (req) => {
+        const { projectId } = req.params;
+        const project = await fastify.core.project.get(projectId);
+        const cfg = await fastify.core.sprite.getConfig(projectId);
+        const localRoot = String(cfg?.localImageRoot ?? "").trim();
+        const root = localRoot || project?.assets?.iconsSvn?.localDir;
+        if (!root) {
+            return toBrowseEntriesDto("", []);
+        }
+        const entries = listDir(root).filter(e => e.kind === "dir");
+        if (localRoot) {
+            const rootFiles = listDir(root).filter((e) => e.kind === "file" && (e.ext === ".png" || e.ext === ".svg"));
+            if (rootFiles.length > 0) {
+                entries.unshift({ name: "root", kind: "dir", ext: undefined });
+            }
+        }
+        return toBrowseEntriesDto(root, entries);
+    });
+    fastify.get("/icons/files/:projectId", async (req) => {
+        const { projectId } = req.params;
+        const group = req.query?.group;
+        const project = await fastify.core.project.get(projectId);
+        const cfg = await fastify.core.sprite.getConfig(projectId);
+        const localRoot = String(cfg?.localImageRoot ?? "").trim();
+        const root = localRoot || project?.assets?.iconsSvn?.localDir;
+        if (!root) {
+            return toBrowseEntriesDto("", []);
+        }
+        const isRootGroup = !!localRoot && (group === "root");
+        const groupDir = isRootGroup ? root : safeJoin(root, group || "");
+        const entries = listDir(groupDir)
+            .filter(e => e.kind === "file")
+            .map(e => ({
+            ...e,
+            url: localRoot
+                ? `/api/static/local/${projectId}/${isRootGroup ? e.name : `${group}/${e.name}`}`
+                : `/api/static/svn/${projectId}/icons/${group}/${e.name}`,
+        }));
+        return toBrowseEntriesDto(groupDir, entries);
+    });
+    fastify.get("/images/list/:projectId", async (req) => {
+        const { projectId } = req.params;
+        const quickProjectId = await (0, sprite_quick_utils_1.resolveEnabledRemoteProjectId)(fastify, projectId);
+        if (quickProjectId) {
+            const cfg = await fastify.core.sprite.getConfig(projectId);
+            const baseUrl = (0, sprite_quick_utils_1.getBaseUrl)(cfg);
+            const dir = String(req.query?.dir ?? "").trim();
+            const cache = await (0, sprite_quick_utils_1.fetchAndCacheRemoteMiscImages)(fastify, baseUrl, quickProjectId);
+            return (0, sprite_quick_utils_1.buildBrowseFromCache)(quickProjectId, cache, dir || undefined);
+        }
+        const project = await fastify.core.project.get(projectId);
+        const root = project?.assets?.cutImageSvn?.localDir;
+        if (!root) {
+            return toBrowseEntriesDto("", []);
+        }
+        const dir = String(req.query?.dir ?? "").trim();
+        if (dir.split(/[\\/]/g).some(seg => seg === "..")) {
+            return toBrowseFilesDto(root, "", []);
+        }
+        const absDir = dir ? safeJoin(root, dir) : root;
+        if (!node_fs_1.default.existsSync(absDir))
+            return toBrowseFilesDto(root, dir, []);
+        const entries = listDir(absDir).map(e => {
+            if (e.kind === "file") {
+                const rel = dir ? `${dir}/${e.name}` : e.name;
+                return {
+                    ...e,
+                    url: `/api/static/svn/${projectId}/images/${rel}`,
+                };
+            }
+            else if (e.kind === "dir") {
+                const rel = dir ? `${dir}/${e.name}` : e.name;
+                return {
+                    ...e,
+                    fileCount: countFiles(safeJoin(root, rel)),
+                };
+            }
+            return e;
+        });
+        return toBrowseFilesDto(root, dir, entries);
+    });
+}

package/lib/routes/sprite/sprite-quick.utils.d.ts

@@ -0,0 +1,19 @@
+import type { FastifyInstance } from "fastify";
+import type { QuickSpriteProjectDto, QuickGenerateResponseDto, QuickImagesResponseDto, SpriteSnapshotDto, SpriteGroupItemDto, BrowseFilesDto } from "@yinuo-ngm/protocol";
+import type { SpriteConfig } from "@yinuo-ngm/sprite";
+export declare function getBaseUrl(cfg?: {
+    quickSpriteBaseUrl?: string;
+} | null): string;
+export declare const QUICK_SPRITE_PROXY_PREFIX = "/api/sprite/proxy";
+export declare function buildQuickPreviewUrl(localProjectId: string, group: string): string;
+export declare function quickFetch<T>(fastify: FastifyInstance, baseUrl: string, path: string, init?: RequestInit): Promise<T>;
+export declare function resolveEnabledRemoteProjectId(fastify: FastifyInstance, projectId: string): Promise<string | null>;
+export declare function fetchRemoteProject(fastify: FastifyInstance, baseUrl: string, quickProjectId: string): Promise<QuickSpriteProjectDto | null>;
+export declare function mapToGroup(result: QuickGenerateResponseDto, localProjectId: string, prefix: string, spriteUrlTemplate: string): SpriteGroupItemDto;
+export declare function mapQuickGroupsToSnapshot(projectId: string, results: QuickGenerateResponseDto[], remoteProj: QuickSpriteProjectDto | null, localCfg: SpriteConfig | null): SpriteSnapshotDto;
+export declare function copyRawResponseHeaders(response: Response, reply: any): void;
+export declare function hasQuickSprite(fastify: FastifyInstance, projectId: string): Promise<boolean>;
+export declare function fetchAndCacheRemoteMiscImages(fastify: FastifyInstance, baseUrl: string, quickProjectId: string, forceRefresh?: boolean): Promise<QuickImagesResponseDto>;
+export declare function buildBrowseFromCache(quickProjectId: string, cache: QuickImagesResponseDto, dir?: string): BrowseFilesDto;
+export declare const MISC_PROXY_PREFIX = "/api/sprite/misc-proxy";
+export declare function buildRemoteMiscUrl(baseUrl: string, quickProjectId: string, filename: string): string;