@yinuo-ngm/server 1.0.11 → 1.0.13

package/lib/app.js

@@ -13,6 +13,7 @@ const static_plugin_1 = __importDefault(require("./plugins/static.plugin"));
 const success_handle_plugin_1 = __importDefault(require("./plugins/success-handle.plugin"));
 const ws_plugin_1 = __importDefault(require("./plugins/ws/ws.plugin"));
 const api_client_plugin_1 = __importDefault(require("./plugins/api-client.plugin"));
+const env_1 = require("./env");
 function normalizeLogLevel(v) {
     const lv = (v ?? "").toLowerCase().trim();
     if (!lv)
@@ -22,7 +23,8 @@ function normalizeLogLevel(v) {
     return "info";
 }
 function createFastifyLogger() {
-    const level = normalizeLogLevel(process.env.NGM_LOG_LEVEL);
+    const level = normalizeLogLevel(env_1.env.logLevel);
+    console.log(`Logger initialized with level: ${level || "silent (disabled)"}`);
     if (!level)
         return false;
     const isDev = process.env.NODE_ENV !== "production";

package/lib/plugins/error-handler.plugin.js

@@ -11,11 +11,18 @@ exports.ERROR_STATUS = {
     PROJECT_NOT_FOUND: 404,
     PROJECT_ROOT_INVALID: 400,
     PROJECT_ALREADY_EXISTS: 409,
+    PROJECT_ID_REQUIRED: 400,
     PROJECT_IMPORT_NOT_EXISTS: 404,
     PROJECT_IMPORT_NOT_DIR: 400,
     PROJECT_IMPORT_ALREADY_REGISTERED: 409,
     PROJECT_IMPORT_NOT_RECOGNIZED: 422,
     PROJECT_IMPORT_SCAN_FAILED: 500,
+    ASSET_NOT_FOUND: 404,
+    ASSET_KIND_NOT_SUPPORTED: 400,
+    ASSET_URL_REQUIRED: 400,
+    ASSET_LABEL_REQUIRED: 400,
+    ASSET_URL_INVALID: 400,
+    ASSET_MODE_INVALID: 400,
     INVALID_NAME: 400,
     TARGET_EXISTS: 409,
     INVALID_REPO_URL: 400,
@@ -75,6 +82,13 @@ exports.ERROR_STATUS = {
     UNKNOWN_ERROR: 500,
     BAD_REQUEST: 400,
     NOT_IMPLEMENTED: 501,
+    NOT_FOUND: 404,
+    SVN_SYNC_ALREADY_RUNNING: 409,
+    SVN_SYNC_FAILED: 500,
+    SVN_SOURCE_ID_REQUIRED: 400,
+    SPRITE_CONFIG_NOT_FOUND: 404,
+    SPRITE_ICONS_ROOT_NOT_FOUND: 404,
+    SPRITE_GROUP_NOT_FOUND: 404,
 };
 function mapStatus(code) {
     return exports.ERROR_STATUS[code] ?? 400;

package/lib/plugins/static.plugin.js

@@ -11,16 +11,14 @@ const fs_1 = __importDefault(require("fs"));
 exports.default = (0, fastify_plugin_1.default)(async function staticPlugin(fastify) {
     const webRoot = path_1.default.resolve(__dirname, "../../www/browser");
     const dataDir = env_1.env.dataDir;
-    const spritesRoot = path_1.default.join(dataDir, "sprites");
-    const spriteCssRoot = path_1.default.join(dataDir, "sprite-css");
-    for (const dir of [dataDir, spritesRoot, spriteCssRoot]) {
+    const spritesRoot = path_1.default.join(env_1.env.dataDir, "cache", "sprites");
+    for (const dir of [dataDir]) {
         if (!fs_1.default.existsSync(dir))
             fs_1.default.mkdirSync(dir, { recursive: true });
     }
     fastify.log.info(`[static] serving webapp from ${webRoot}`);
     fastify.log.info(`[static] dataDir=${dataDir}`);
-    fastify.log.info(`[static] serving sprites from ${spritesRoot} at /sprites/`);
-    fastify.log.info(`[static] serving sprite-css from ${spriteCssRoot} at /sprite-css/`);
+    fastify.log.info(`[static] serving sprites from ${spritesRoot} `);
     await fastify.register(static_1.default, {
         root: webRoot,
         index: "index.html",
@@ -31,18 +29,12 @@ exports.default = (0, fastify_plugin_1.default)(async function staticPlugin(fast
         prefix: "/sprites/",
         decorateReply: false,
     });
-    await fastify.register(static_1.default, {
-        root: spriteCssRoot,
-        prefix: "/sprite-css/",
-        decorateReply: false,
-    });
     fastify.setNotFoundHandler((req, reply) => {
         const url = req.url || "";
         const isSpaFallbackCandidate = req.method === "GET" &&
             !url.startsWith("/api") &&
             !url.startsWith("/ws") &&
-            !url.startsWith("/sprites/") &&
-            !url.startsWith("/sprite-css/");
+            !url.startsWith("/sprites/");
         if (isSpaFallbackCandidate) {
             return reply.sendFile("index.html");
         }

package/lib/plugins/ws/topics/index.d.ts

@@ -1 +1,3 @@
 export * from "./task.ws";
+export * from "./syslog.ws";
+export * from "./svn.ws";

package/lib/plugins/ws/topics/index.js

@@ -15,3 +15,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./task.ws"), exports);
+__exportStar(require("./syslog.ws"), exports);
+__exportStar(require("./svn.ws"), exports);

package/lib/plugins/ws/topics/svn.ws.d.ts

@@ -0,0 +1,9 @@
+import type { SvnEventPayloadMap, SvnEventType, SvnRuntime } from "@yinuo-ngm/core";
+import { WsContext } from "../ws.context";
+import { TopicHandler } from "../ws.router";
+export type SvnSyncWsDeps = {
+    getSvnRuntimeByProjectId?: (projectId: string, tail?: number) => Promise<SvnRuntime[]>;
+};
+export declare function createSvnSyncTopicHandler(deps: SvnSyncWsDeps, getAllClients: () => Iterable<WsContext>): TopicHandler & {
+    pushEvent<K extends SvnEventType>(type: K, payload: SvnEventPayloadMap[K]): void;
+};

package/lib/plugins/ws/topics/svn.ws.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSvnSyncTopicHandler = createSvnSyncTopicHandler;
+const keyOf = (projectId) => `svn:${projectId}`;
+function createSvnSyncTopicHandler(deps, getAllClients) {
+    return {
+        topic: "svn",
+        async sub(ctx, msg) {
+            const projectId = String(msg?.projectId ?? "").trim();
+            if (!projectId) {
+                ctx.send({ op: "error", code: "PROJECT_ID_REQUIRED", message: "projectId is required", ts: Date.now() });
+                return;
+            }
+            const t = Number(msg?.tail ?? 0) || 0;
+            ctx.addSub("svn", keyOf(projectId));
+            if (deps.getSvnRuntimeByProjectId) {
+                const runtimes = await deps.getSvnRuntimeByProjectId(projectId, t);
+                if (runtimes?.length) {
+                    runtimes.forEach(runtime => {
+                        const m = {
+                            op: "svn.event",
+                            type: "runtime",
+                            payload: runtime,
+                            ts: Date.now(),
+                        };
+                        ctx.send(m);
+                    });
+                }
+            }
+        },
+        async unsub(ctx, msg) {
+            const projectId = String(msg?.projectId ?? "").trim();
+            if (!projectId) {
+                ctx.send({ op: "error", code: "PROJECT_ID_REQUIRED", message: "projectId is required", ts: Date.now() });
+                return;
+            }
+            ctx.delSub("svn", keyOf(projectId));
+        },
+        pushEvent(type, payload) {
+            const m = { op: "svn.event", type, payload, ts: Date.now() };
+            for (const c of getAllClients())
+                if (c.hasSub("svn", keyOf(payload.projectId)))
+                    c.send(m);
+        }
+    };
+}

package/lib/plugins/ws/ws.plugin.js

@@ -7,7 +7,6 @@ const core_1 = require("@yinuo-ngm/core");
 const websocket_1 = __importDefault(require("@fastify/websocket"));
 const fastify_plugin_1 = __importDefault(require("fastify-plugin"));
 const topics_1 = require("./topics");
-const syslog_ws_1 = require("./topics/syslog.ws");
 const ws_context_1 = require("./ws.context");
 const ws_router_1 = require("./ws.router");
 function uid() {
@@ -23,36 +22,53 @@ exports.default = (0, fastify_plugin_1.default)(async function wsPlugin(fastify)
         resizeRun: (taskId, cols, rows) => fastify.core.task.resizeRun(taskId, cols, rows),
     }, () => clients.values());
     router.register(taskHandler);
-    const syslogHandler = (0, syslog_ws_1.createSyslogTopicHandler)({ getSyslogTail: (tail) => fastify.core.sysLog.tail(tail) }, () => clients.values());
+    const syslogHandler = (0, topics_1.createSyslogTopicHandler)({ getSyslogTail: (tail) => fastify.core.sysLog.tail(tail) }, () => clients.values());
     router.register(syslogHandler);
+    const svnSyncHandler = (0, topics_1.createSvnSyncTopicHandler)({
+        getSvnRuntimeByProjectId: (projectId, tail) => fastify.core.svnSync.getRuntimeByProjectId(projectId, tail),
+    }, () => clients.values());
+    router.register(svnSyncHandler);
     const offs = [];
-    offs.push(fastify.core.events.on(core_1.Events.TASK_OUTPUT, (e) => {
+    const events = fastify.core.events;
+    offs.push(events.on(core_1.Events.TASK_OUTPUT, (e) => {
         taskHandler.pushOutput(e);
     }));
-    offs.push(fastify.core.events.on(core_1.Events.TASK_STARTED, (e) => {
+    offs.push(events.on(core_1.Events.TASK_STARTED, (e) => {
         taskHandler.pushEvent("started", e);
     }));
-    offs.push(fastify.core.events.on(core_1.Events.TASK_STOP_REQUESTED, (e) => {
+    offs.push(events.on(core_1.Events.TASK_STOP_REQUESTED, (e) => {
         taskHandler.pushEvent("stopRequested", e);
     }));
-    offs.push(fastify.core.events.on(core_1.Events.TASK_EXITED, (e) => {
+    offs.push(events.on(core_1.Events.TASK_EXITED, (e) => {
         taskHandler.pushEvent("exited", e);
     }));
-    offs.push(fastify.core.events.on(core_1.Events.TASK_FAILED, (e) => {
+    offs.push(events.on(core_1.Events.TASK_FAILED, (e) => {
         taskHandler.pushEvent("failed", e);
     }));
-    offs.push(fastify.core.events.on(core_1.Events.SYSLOG_APPENDED, (e) => {
+    offs.push(events.on(core_1.Events.SYSLOG_APPENDED, (e) => {
         syslogHandler.push(e.entry);
     }));
-    offs.push(fastify.core.events.on(core_1.Events.PROJECT_BOOTSTRAP_DONE, (e) => {
+    offs.push(events.on(core_1.Events.PROJECT_BOOTSTRAP_DONE, (e) => {
         taskHandler.pushEvent("bootstrapDone", e);
     }));
-    offs.push(fastify.core.events.on(core_1.Events.PROJECT_BOOTSTRAP_FAILED, (e) => {
+    offs.push(events.on(core_1.Events.PROJECT_BOOTSTRAP_FAILED, (e) => {
         taskHandler.pushEvent("bootstrapFailed", e);
     }));
-    offs.push(fastify.core.events.on(core_1.Events.PROJECT_BOOTSTRAP_NEED_PICK_ROOT, (e) => {
+    offs.push(events.on(core_1.Events.PROJECT_BOOTSTRAP_NEED_PICK_ROOT, (e) => {
         taskHandler.pushEvent("bootstrapNeedPickRoot", e);
     }));
+    offs.push(events.on(core_1.Events.SVN_SYNC_STARTED, (e) => {
+        svnSyncHandler.pushEvent("started", e);
+    }));
+    offs.push(events.on(core_1.Events.SVN_SYNC_OUTPUT, (e) => {
+        svnSyncHandler.pushEvent("output", e);
+    }));
+    offs.push(events.on(core_1.Events.SVN_SYNC_PROGRESS, (e) => {
+        svnSyncHandler.pushEvent("progress", e);
+    }));
+    offs.push(events.on(core_1.Events.SVN_SYNC_DONE, (e) => {
+        svnSyncHandler.pushEvent("done", e);
+    }));
     fastify.addHook("onClose", async () => {
         offs.forEach((off) => {
             try {

package/lib/routes/index.js

@@ -14,6 +14,9 @@ const sprite_routes_1 = require("./sprite.routes");
 const system_routes_1 = __importDefault(require("./system.routes"));
 const task_routes_1 = __importDefault(require("./task.routes"));
 const api_client_1 = require("./api-client");
+const svn_routes_1 = __importDefault(require("./svn.routes"));
+const sprite_browse_routes_1 = __importDefault(require("./sprite-browse.routes"));
+const static_files_routes_1 = __importDefault(require("./static-files.routes"));
 async function routes(fastify) {
     await fastify.register(system_routes_1.default);
     await fastify.register(task_routes_1.default, { prefix: '/api/tasks' });
@@ -24,6 +27,9 @@ async function routes(fastify) {
     await fastify.register(dashboard_routes_1.default, { prefix: '/api/dashboard' });
     await fastify.register(rss_routes_1.default, { prefix: '/api/rss' });
     await fastify.register(sprite_routes_1.spriteRoutes, { prefix: '/api/sprite' });
+    await fastify.register(svn_routes_1.default, { prefix: '/api/svn' });
+    await fastify.register(sprite_browse_routes_1.default, { prefix: '/api/sprite/browse' });
+    await fastify.register(static_files_routes_1.default, { prefix: '/api/static' });
     await fastify.register(api_client_1.apiClientEnvsRoutes, { prefix: '/api/client/envs' });
     await fastify.register(api_client_1.apiClientRequestsRoutes, { prefix: '/api/client/requests' });
     await fastify.register(api_client_1.apiClientHistoryRoutes, { prefix: '/api/client/history' });

package/lib/routes/project.routes.js

@@ -69,7 +69,7 @@ async function projectRoutes(fastify) {
         const project = await fastify.core.project.get(id);
         return project;
     });
-    fastify.get("/delete/:id", async (req) => {
+    fastify.delete("/delete/:id", async (req) => {
         const { id } = req.params;
         await fastify.core.project.remove(id);
         return { id };
@@ -158,7 +158,21 @@ async function projectRoutes(fastify) {
         if (typeof body?.name !== "string" || body.name.trim() === "") {
             throw new core_1.AppError("INVALID_NAME", "name must be a non-empty string");
         }
-        const updated = await fastify.core.project.edit(id, { name: body.name.trim(), description: body.description?.trim(), repoPageUrl: body.repoPageUrl?.trim() });
+        const updated = await fastify.core.project.edit(id, {
+            name: body.name.trim(),
+            description: body.description?.trim(),
+            repoPageUrl: body.repoPageUrl?.trim(),
+        });
+        return updated;
+    });
+    fastify.post("/updateAssets/:id", async (req) => {
+        const { id } = req.params;
+        const body = req.body;
+        const assets = body?.assets;
+        if (!assets || !assets.iconsSvn) {
+            throw new core_1.AppError("BAD_REQUEST", "参数错误，assets.iconsSvn 是必需的");
+        }
+        const updated = await fastify.core.project.updateAssets(id, assets);
         return updated;
     });
     fastify.post("/openInEditor/:id", async (req) => {

package/lib/routes/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-browse.routes.js

@@ -0,0 +1,107 @@
+"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 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 Error("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;
+}
+async function spriteBrowseRoutes(fastify) {
+    fastify.get("/icons/groups/:projectId", async (req) => {
+        const { projectId } = req.params;
+        const project = await fastify.core.project.get(projectId);
+        const root = project?.assets?.iconsSvn?.localDir;
+        if (!root) {
+            return { root: "", entries: [] };
+        }
+        return { root, entries: listDir(root).filter(e => e.kind === "dir") };
+    });
+    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 root = project?.assets?.iconsSvn?.localDir;
+        if (!root) {
+            return { root: "", entries: [] };
+        }
+        const groupDir = safeJoin(root, group || '');
+        const entries = listDir(groupDir)
+            .filter(e => e.kind === "file")
+            .map(e => ({
+            ...e,
+            url: `/api/static/svn/${projectId}/icons/${group}/${e.name}`,
+        }));
+        return { root: groupDir, entries };
+    });
+    fastify.get("/images/list/:projectId", async (req) => {
+        const { projectId } = req.params;
+        const project = await fastify.core.project.get(projectId);
+        const root = project?.assets?.cutImageSvn?.localDir;
+        if (!root) {
+            return { root: "", entries: [] };
+        }
+        const dir = String(req.query?.dir ?? "").trim();
+        if (dir.split(/[\\/]/g).some(seg => seg === "..")) {
+            return { root, dir: "", entries: [] };
+        }
+        const absDir = dir ? safeJoin(root, dir) : root;
+        if (!node_fs_1.default.existsSync(absDir))
+            return { root, dir, entries: [] };
+        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 { root, dir, entries };
+    });
+}

package/lib/routes/sprite.routes.js

@@ -4,71 +4,50 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.spriteRoutes = spriteRoutes;
-const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
-const env_1 = require("../env");
-const sprite_1 = require("@yinuo-ngm/sprite");
-function ensureDir(dir) {
-    if (!node_fs_1.default.existsSync(dir))
-        node_fs_1.default.mkdirSync(dir, { recursive: true });
-}
+const core_1 = require("@yinuo-ngm/core");
 async function spriteRoutes(fastify) {
-    fastify.post("/generate", async (req) => {
-        try {
-            const { projectId } = req.params;
-            const body = req.body || {};
-            const group = String(body.group || "").trim();
-            if (!group) {
-                throw new Error("group is required");
-            }
-            const prefix = (body.prefix || "sl").trim() || "sl";
-            const forceRefresh = !!body.forceRefresh;
-            const algorithm = body.algorithm || "binary-tree";
-            const persistLess = body.persistLess ?? true;
-            const iconsRoot = node_path_1.default.join(env_1.env.dataDir, "icons", projectId, "icons");
-            const groupDir = node_path_1.default.join(iconsRoot, group);
-            if (!node_fs_1.default.existsSync(groupDir)) {
-                throw new Error(`Icon group not found: ${groupDir}`);
-            }
-            const outDir = node_path_1.default.join(env_1.env.dataDir, "sprites", projectId);
-            ensureDir(outDir);
-            const spriteUrl = `/sprites/${encodeURIComponent(projectId)}/${encodeURIComponent(group)}.png`;
-            const type = (0, sprite_1.detectGroupType)(groupDir);
-            let data;
-            if (type === "mixed") {
-                throw new Error(`分组 ${group} 同时存在 png 与 svg，请统一格式（建议拆分目录）`);
-            }
-            if (type === "svg") {
-                data = await (0, sprite_1.generateSvgGroup)({
-                    group,
-                    groupDir,
-                    prefix,
-                    urlResolver: ({ group, file }) => `/icons/${encodeURIComponent(projectId)}/icons/${encodeURIComponent(group)}/${encodeURIComponent(file)}`,
-                });
-            }
-            else {
-                data = await (0, sprite_1.generatePngGroup)({
-                    group,
-                    groupDir,
-                    outDir,
-                    spriteUrl,
-                    css: {
-                        prefix,
-                        spriteUrlResolver: ({ spriteUrl }) => spriteUrl,
-                    },
-                    cache: {
-                        enabled: true,
-                        forceRefresh,
-                        persistLess,
-                    },
-                    spritesmith: { algorithm },
-                });
+    fastify.get("/config/:projectId", async (req) => {
+        const { projectId } = req.params;
+        return await fastify.core.sprite.getConfig(projectId);
+    });
+    fastify.post("/config/:projectId", async (req) => {
+        const { projectId } = req.params;
+        const body = req.body;
+        if (!body || !body.config || !body.assets) {
+            throw new core_1.AppError('BAD_REQUEST', 'Missing config or assets in request body');
+        }
+        const nextCfg = body.config;
+        const nextAssets = body.assets;
+        if (!nextAssets.iconsSvn) {
+            throw new core_1.AppError('BAD_REQUEST', 'iconsSvn asset is required');
+        }
+        if (nextCfg.localDir) {
+            nextAssets.iconsSvn.localDir = node_path_1.default.join(nextCfg.localDir, nextAssets.iconsSvn.label || 'icons');
+            if (nextAssets.cutImageSvn) {
+                nextAssets.cutImageSvn.localDir = node_path_1.default.join(nextCfg.localDir, nextAssets.cutImageSvn.label || 'images');
             }
-            return data;
         }
-        catch (e) {
-            req.log.error(e);
-            throw new Error("Failed to generate sprite");
+        const p = await fastify.core.project.updateAssets(projectId, nextAssets);
+        if (p.assets?.iconsSvn) {
+            nextCfg.sourceId = p.assets.iconsSvn.id;
         }
+        const cfg = await fastify.core.sprite.createConfig(projectId, nextCfg);
+        return { cfg, project: p };
+    });
+    fastify.post("/generate/:projectId", async (req) => {
+        const { projectId } = req.params;
+        const body = req.body || {};
+        const result = await fastify.core.sprite.generate(projectId, {
+            groups: body.groups,
+            forceRefresh: !!body.forceRefresh,
+            concurrency: body.concurrency ?? 1,
+            continueOnError: body.continueOnError ?? true,
+        });
+        return result;
+    });
+    fastify.get("/list/:projectId", async (req) => {
+        const { projectId } = req.params;
+        return await fastify.core.sprite.getSprites(projectId);
     });
 }

package/lib/routes/static-files.routes.d.ts

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

package/lib/routes/static-files.routes.js

@@ -0,0 +1,83 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = staticFileRoutes;
+const core_1 = require("@yinuo-ngm/core");
+const mime_types_1 = __importDefault(require("mime-types"));
+const node_fs_1 = __importStar(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+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 Error("INVALID_PATH");
+    }
+    return resolved;
+}
+async function staticFileRoutes(fastify) {
+    fastify.get("/cache/sprites/:projectId/*", async (req, reply) => {
+        const { projectId } = req.params;
+        const file = req.params["*"];
+        const cacheDir = fastify.core.sprite.ensureCacheDir(projectId);
+        const filePath = safeJoin(cacheDir, file);
+        if (!node_fs_1.default.existsSync(filePath)) {
+            throw new core_1.AppError("NOT_FOUND", "Requested file not found in cache");
+        }
+        const ct = mime_types_1.default.lookup(filePath) || "application/octet-stream";
+        reply.header("Content-Type", ct);
+        return reply.send((0, node_fs_1.createReadStream)(filePath));
+    });
+    fastify.get("/svn/:projectId/:kind/*", async (req, reply) => {
+        const { projectId, kind } = req.params;
+        const file = req.params["*"];
+        const project = await fastify.core.project.get(projectId);
+        const root = kind === "icons"
+            ? project?.assets?.iconsSvn?.localDir
+            : project?.assets?.cutImageSvn?.localDir;
+        if (!root) {
+            throw new core_1.AppError("ASSET_NOT_FOUND", "Project asset source not found");
+        }
+        const filePath = safeJoin(root, file);
+        if (!node_fs_1.default.existsSync(filePath)) {
+            throw new core_1.AppError("NOT_FOUND", "Requested file not found in SVN");
+        }
+        const ct = mime_types_1.default.lookup(filePath) || "application/octet-stream";
+        reply.header("Content-Type", ct);
+        return reply.send((0, node_fs_1.createReadStream)(filePath));
+    });
+}

package/lib/routes/svn.routes.d.ts

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

package/lib/routes/svn.routes.js

@@ -0,0 +1,53 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = svnRoutes;
+const core_1 = require("@yinuo-ngm/core");
+const node_path_1 = __importDefault(require("node:path"));
+const env_1 = require("../env");
+async function svnRoutes(fastify) {
+    fastify.post("/sync/:projectId", async (req) => {
+        const { projectId } = req.params;
+        const p = await fastify.core.project.get(projectId);
+        const assets = p.assets;
+        if (!assets) {
+            throw new core_1.AppError('ASSET_NOT_FOUND', 'Project assets are required for SVN sync');
+        }
+        const { iconsSvn, cutImageSvn } = assets;
+        const svnSources = [iconsSvn, cutImageSvn].filter(s => s && s.kind === "svn");
+        const results = [];
+        for (const s of svnSources) {
+            let localDir = s.localDir;
+            if (!localDir) {
+                localDir = node_path_1.default.join(env_1.env.dataDir, 'svn', projectId, s.label || s.id);
+            }
+            const r = await fastify.core.svnSync.sync(projectId, s.id, localDir, s.url);
+            results.push(r);
+        }
+        return results;
+    });
+    fastify.get("/runtime/:projectId", async (req) => {
+        const { projectId } = req.params;
+        const runtimes = await fastify.core.svnSync.getRuntimeByProjectId(projectId);
+        return runtimes;
+    });
+    fastify.post("/sync/stream/:projectId", async (req) => {
+        const { projectId } = req.params;
+        const assets = (await fastify.core.project.get(projectId)).assets;
+        if (!assets) {
+            throw new core_1.AppError('ASSET_NOT_FOUND', 'Project assets are required for SVN sync');
+        }
+        const { iconsSvn, cutImageSvn } = assets;
+        const svnSources = [iconsSvn, cutImageSvn].filter(s => s && s.kind === "svn");
+        for (const s of svnSources) {
+            let localDir = s.localDir;
+            if (!localDir) {
+                localDir = node_path_1.default.join(env_1.env.dataDir, 'svn', projectId, s.label || s.id);
+            }
+            await fastify.core.svnSync.syncWithStream(projectId, s.id, localDir, s.url);
+        }
+        return { message: "SVN sync started" };
+    });
+}