@yinuo-ngm/server 1.0.19 → 1.0.21

package/lib/routes/project.routes.js

@@ -37,10 +37,82 @@ 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,
+        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;
@@ -55,7 +127,7 @@ async function projectRoutes(fastify) {
                 ...(body.env !== undefined ? { env: body.env } : {}),
                 ...(body.scripts !== undefined ? { scripts: body.scripts } : {}),
             });
-            return updated;
+            return toProjectDto(updated);
         }
         catch (err) {
             if (err instanceof Error) {
@@ -67,7 +139,7 @@ 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);
     });
     fastify.delete("/delete/:id", async (req) => {
         const { id } = req.params;
@@ -76,7 +148,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 +158,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 +185,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 +204,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 +218,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 +227,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 +245,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 +255,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-browse.routes.js

@@ -31,7 +31,7 @@ function listDir(root) {
         .filter(d => !SKIP.has(d.name) && !d.name.startsWith("."))
         .map(d => ({
         name: d.name,
-        kind: d.isDirectory() ? "dir" : "file",
+        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) {
@@ -45,6 +45,12 @@ function countFiles(dir) {
         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;
@@ -53,7 +59,7 @@ async function spriteBrowseRoutes(fastify) {
         const localRoot = String(cfg?.localImageRoot ?? "").trim();
         const root = localRoot || project?.assets?.iconsSvn?.localDir;
         if (!root) {
-            return { root: "", entries: [] };
+            return toBrowseEntriesDto("", []);
         }
         const entries = listDir(root).filter(e => e.kind === "dir");
         if (localRoot) {
@@ -62,7 +68,7 @@ async function spriteBrowseRoutes(fastify) {
                 entries.unshift({ name: "root", kind: "dir", ext: undefined });
             }
         }
-        return { root, entries };
+        return toBrowseEntriesDto(root, entries);
     });
     fastify.get("/icons/files/:projectId", async (req) => {
         const { projectId } = req.params;
@@ -72,10 +78,10 @@ async function spriteBrowseRoutes(fastify) {
         const localRoot = String(cfg?.localImageRoot ?? "").trim();
         const root = localRoot || project?.assets?.iconsSvn?.localDir;
         if (!root) {
-            return { root: "", entries: [] };
+            return toBrowseEntriesDto("", []);
         }
         const isRootGroup = !!localRoot && (group === "root");
-        const groupDir = isRootGroup ? root : safeJoin(root, group || '');
+        const groupDir = isRootGroup ? root : safeJoin(root, group || "");
         const entries = listDir(groupDir)
             .filter(e => e.kind === "file")
             .map(e => ({
@@ -84,22 +90,22 @@ async function spriteBrowseRoutes(fastify) {
                 ? `/api/static/local/${projectId}/${isRootGroup ? e.name : `${group}/${e.name}`}`
                 : `/api/static/svn/${projectId}/icons/${group}/${e.name}`,
         }));
-        return { root: groupDir, entries };
+        return toBrowseEntriesDto(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: [] };
+            return toBrowseEntriesDto("", []);
         }
         const dir = String(req.query?.dir ?? "").trim();
         if (dir.split(/[\\/]/g).some(seg => seg === "..")) {
-            return { root, dir: "", entries: [] };
+            return toBrowseFilesDto(root, "", []);
         }
         const absDir = dir ? safeJoin(root, dir) : root;
         if (!node_fs_1.default.existsSync(absDir))
-            return { root, dir, entries: [] };
+            return toBrowseFilesDto(root, dir, []);
         const entries = listDir(absDir).map(e => {
             if (e.kind === "file") {
                 const rel = dir ? `${dir}/${e.name}` : e.name;
@@ -112,11 +118,11 @@ async function spriteBrowseRoutes(fastify) {
                 const rel = dir ? `${dir}/${e.name}` : e.name;
                 return {
                     ...e,
-                    fileCount: countFiles(safeJoin(root, rel))
+                    fileCount: countFiles(safeJoin(root, rel)),
                 };
             }
             return e;
         });
-        return { root, dir, entries };
+        return toBrowseFilesDto(root, dir, entries);
     });
 }

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

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

package/lib/routes/sprite.routes.js

@@ -6,27 +6,75 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.spriteRoutes = spriteRoutes;
 const node_path_1 = __importDefault(require("node:path"));
 const errors_1 = require("@yinuo-ngm/errors");
+function toSpriteConfigDto(cfg) {
+    return {
+        projectId: cfg.projectId,
+        enabled: cfg.enabled,
+        sourceId: cfg.sourceId,
+        localDir: cfg.localDir,
+        prefix: cfg.prefix,
+        template: cfg.template,
+        spriteUrl: cfg.spriteUrl,
+        spriteExportDir: cfg.spriteExportDir,
+        lessExportDir: cfg.lessExportDir,
+        algorithm: cfg.algorithm,
+        persistLess: cfg.persistLess,
+        updatedAt: cfg.updatedAt,
+        localImageRoot: cfg.localImageRoot,
+        localCacheDir: cfg.localCacheDir,
+    };
+}
+function toSpriteGroupItemDto(item) {
+    return {
+        group: item.group,
+        kind: item.kind,
+        previewSpriteUrl: item.previewSpriteUrl,
+        spriteUrl: item.spriteUrl,
+        meta: item.meta,
+        lessText: item.lessText,
+        exported: item.exported,
+        status: item.status,
+        error: item.error,
+    };
+}
+function toSpriteSnapshotDto(snapshot) {
+    return {
+        projectId: snapshot.projectId,
+        sourceId: snapshot.sourceId,
+        iconsRoot: snapshot.iconsRoot,
+        cacheOutDir: snapshot.cacheOutDir,
+        config: toSpriteConfigDto(snapshot.config),
+        total: snapshot.total,
+        success: snapshot.success,
+        failed: snapshot.failed,
+        groups: (snapshot.groups ?? []).map(toSpriteGroupItemDto),
+    };
+}
+function toGenerateSpriteResultDto(snapshot) {
+    return toSpriteSnapshotDto(snapshot);
+}
 async function spriteRoutes(fastify) {
     fastify.get("/config/:projectId", async (req) => {
         const { projectId } = req.params;
-        return await fastify.core.sprite.getConfig(projectId);
+        const cfg = await fastify.core.sprite.getConfig(projectId);
+        return cfg ? toSpriteConfigDto(cfg) : null;
     });
     fastify.post("/config/:projectId", async (req) => {
         const { projectId } = req.params;
         const body = req.body;
         if (!body || !body.config) {
-            throw new errors_1.GlobalError(errors_1.GlobalErrorCodes.BAD_REQUEST, 'Missing config in request body');
+            throw new errors_1.GlobalError(errors_1.GlobalErrorCodes.BAD_REQUEST, "Missing config in request body");
         }
         const nextCfg = body.config;
-        const nextAssets = body.assets || {};
+        const nextAssets = (body.assets || {});
         const hasLocalImageRoot = !!String(nextCfg.localImageRoot ?? "").trim();
         if (!nextAssets.iconsSvn && !hasLocalImageRoot) {
-            throw new errors_1.GlobalError(errors_1.GlobalErrorCodes.BAD_REQUEST, 'iconsSvn asset or localImageRoot is required');
+            throw new errors_1.GlobalError(errors_1.GlobalErrorCodes.BAD_REQUEST, "iconsSvn asset or localImageRoot is required");
         }
         if (nextCfg.localDir && nextAssets.iconsSvn) {
-            nextAssets.iconsSvn.localDir = node_path_1.default.join(nextCfg.localDir, nextAssets.iconsSvn.label || 'icons');
+            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');
+                nextAssets.cutImageSvn.localDir = node_path_1.default.join(nextCfg.localDir, nextAssets.cutImageSvn.label || "images");
             }
         }
         const shouldUpdateAssets = !!(nextAssets.iconsSvn || nextAssets.cutImageSvn);
@@ -37,7 +85,16 @@ async function spriteRoutes(fastify) {
             nextCfg.sourceId = project.assets.iconsSvn.id;
         }
         const cfg = await fastify.core.sprite.createConfig(projectId, nextCfg);
-        return { cfg, project };
+        const assets = project.assets
+            ? {
+                iconsSvn: project.assets.iconsSvn,
+                cutImageSvn: project.assets.cutImageSvn,
+            }
+            : undefined;
+        return {
+            cfg: toSpriteConfigDto(cfg),
+            project: { id: project.id, name: project.name, root: project.root, assets },
+        };
     });
     fastify.post("/generate/:projectId", async (req) => {
         const { projectId } = req.params;
@@ -48,12 +105,12 @@ async function spriteRoutes(fastify) {
             concurrency: body.concurrency ?? 1,
             continueOnError: body.continueOnError ?? true,
         });
-        return result;
+        return toGenerateSpriteResultDto(result);
     });
     fastify.get("/list/:projectId", async (req) => {
         const { projectId } = req.params;
-        const query = req.query;
-        const local = String(query['local'] ?? '').toLowerCase() === 'true';
-        return await fastify.core.sprite.getSprites(projectId, local);
+        const local = String(req.query?.local ?? "").toLowerCase() === "true";
+        const snapshot = await fastify.core.sprite.getSprites(projectId, local);
+        return toSpriteSnapshotDto(snapshot);
     });
 }

package/lib/routes/svn.routes.js

@@ -4,51 +4,85 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = svnRoutes;
-const errors_1 = require("@yinuo-ngm/errors");
 const node_path_1 = __importDefault(require("node:path"));
 const env_1 = require("../env");
+const errors_1 = require("@yinuo-ngm/errors");
+function toSvnSyncResultDto(result) {
+    return {
+        ok: result.ok,
+        projectId: result.projectId,
+        sourceId: result.sourceId,
+        mode: result.mode,
+        updatedAt: result.updatedAt,
+        desiredUrl: result.desiredUrl,
+        currentUrl: result.currentUrl,
+        stdout: result.stdout,
+        stderr: result.stderr,
+    };
+}
+function toSvnRuntimeDto(runtime) {
+    return {
+        projectId: runtime.projectId,
+        sourceId: runtime.sourceId,
+        lastSyncAt: runtime.lastSyncAt,
+        lastSyncMode: runtime.lastSyncMode,
+        desiredUrl: runtime.desiredUrl,
+        currentUrl: runtime.currentUrl,
+        lastStdout: runtime.lastStdout,
+        lastStderr: runtime.lastStderr,
+    };
+}
+function resolveSources(assets, body) {
+    const includeIcons = !body?.types?.length || body.types.includes("icons");
+    const includeImages = !body?.types?.length || body.types.includes("images");
+    const list = [];
+    if (includeIcons && assets.iconsSvn?.kind === "svn")
+        list.push(assets.iconsSvn);
+    if (includeImages && assets.cutImageSvn?.kind === "svn")
+        list.push(assets.cutImageSvn);
+    return list;
+}
 async function svnRoutes(fastify) {
+    const svnSync = fastify.core.svnSync;
     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 errors_1.CoreError(errors_1.CoreErrorCodes.ASSET_NOT_FOUND, 'Project assets are required for SVN sync');
-            ;
+            throw new errors_1.CoreError(errors_1.CoreErrorCodes.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 svnSources = resolveSources({ iconsSvn, cutImageSvn }, req.body);
         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);
+                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);
+            const r = await svnSync.sync(projectId, s.id, localDir, s.url);
+            results.push(toSvnSyncResultDto(r));
         }
         return results;
     });
     fastify.get("/runtime/:projectId", async (req) => {
         const { projectId } = req.params;
-        const runtimes = await fastify.core.svnSync.getRuntimeByProjectId(projectId);
-        return runtimes;
+        const runtimes = await svnSync.getRuntimeByProjectId(projectId);
+        return runtimes.map(toSvnRuntimeDto);
     });
     fastify.post("/sync/stream/:projectId", async (req) => {
         const { projectId } = req.params;
         const assets = (await fastify.core.project.get(projectId)).assets;
         if (!assets) {
-            throw new errors_1.CoreError(errors_1.CoreErrorCodes.ASSET_NOT_FOUND, 'Project assets are required for SVN sync');
-            ;
+            throw new errors_1.CoreError(errors_1.CoreErrorCodes.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 svnSources = resolveSources({ iconsSvn, cutImageSvn }, req.body);
         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);
+                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);
+            await svnSync.syncWithStream(projectId, s.id, localDir, s.url);
         }
         return { message: "SVN sync started" };
     });

package/lib/routes/task.routes.js

@@ -2,6 +2,55 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = taskRoutes;
 const errors_1 = require("@yinuo-ngm/errors");
+function toTaskDefinitionDto(spec) {
+    return {
+        id: spec.id,
+        projectId: spec.projectId,
+        projectRoot: spec.projectRoot,
+        projectName: spec.projectName,
+        name: spec.name,
+        kind: spec.kind,
+        description: spec.description,
+        command: spec.command,
+        displayCommand: spec.displayCommand,
+        file: spec.file,
+        args: spec.args,
+        runnable: spec.runnable,
+        views: spec.views,
+        capabilities: spec.capabilities,
+    };
+}
+function toTaskRuntimeDto(runtime) {
+    return {
+        taskId: runtime.taskId,
+        projectId: runtime.projectId,
+        name: runtime.name,
+        runId: runtime.runId,
+        status: runtime.status,
+        pid: runtime.pid,
+        startedAt: runtime.startedAt,
+        stoppedAt: runtime.stoppedAt,
+        exitCode: runtime.exitCode,
+        signal: runtime.signal,
+        lastError: runtime.lastError,
+        urls: runtime.urls,
+        lastOutputAt: runtime.lastOutputAt,
+        readyAt: runtime.readyAt,
+        rebuildDurationMs: runtime.rebuildDurationMs,
+        warningsCount: runtime.warningsCount,
+        errorsCount: runtime.errorsCount,
+    };
+}
+function toTaskRowDto(row) {
+    return {
+        spec: toTaskDefinitionDto(row.spec),
+        runtime: row.runtime ? toTaskRuntimeDto(row.runtime) : undefined,
+    };
+}
+function limitFromQuery(query) {
+    const limit = Number(query?.limit);
+    return Math.min(Math.max(Number.isFinite(limit) ? limit : 20, 1), 100);
+}
 async function ensureSpecs(fastify, projectId) {
     const specs = await fastify.core.task.listSpecsByProject(projectId);
     if (specs.length === 0) {
@@ -12,39 +61,82 @@ async function taskRoutes(fastify) {
     fastify.get("/list/:projectId", async (req) => {
         const { projectId } = req.params;
         await ensureSpecs(fastify, projectId);
-        return fastify.core.task.listViewsByProject(projectId);
+        const rows = await fastify.core.task.listViewsByProject(projectId);
+        return rows.map(toTaskRowDto);
     });
     fastify.post("/refresh/:projectId", async (req) => {
         const { projectId } = req.params;
-        return await fastify.core.task.refreshByProject(projectId);
+        const rows = await fastify.core.task.refreshByProject(projectId);
+        return rows.map(toTaskRowDto);
     });
     fastify.post("/start", async (req) => {
         const body = req.body;
         const taskId = body?.taskId?.trim();
         if (!taskId)
             throw new errors_1.CoreError(errors_1.CoreErrorCodes.TASK_ID_REQUIRED, "taskId is required", { body });
-        return await fastify.core.task.start(taskId);
+        const runtime = await fastify.core.task.start(taskId);
+        return toTaskRuntimeDto(runtime);
     });
     fastify.post("/stop", async (req) => {
         const body = req.body;
         const taskId = body?.taskId?.trim();
         if (!taskId)
             throw new errors_1.CoreError(errors_1.CoreErrorCodes.TASK_ID_REQUIRED, "taskId is required", { body });
-        return await fastify.core.task.stop(taskId);
+        const runtime = await fastify.core.task.stop(taskId);
+        return toTaskRuntimeDto(runtime);
     });
     fastify.post("/restart", async (req) => {
         const body = req.body;
         const taskId = body?.taskId?.trim();
         if (!taskId)
             throw new errors_1.CoreError(errors_1.CoreErrorCodes.TASK_ID_REQUIRED, "taskId is required", { body });
-        return await fastify.core.task.restart(taskId);
+        const runtime = await fastify.core.task.restart(taskId);
+        return toTaskRuntimeDto(runtime);
     });
     fastify.get("/status/:taskId", async (req) => {
         const { taskId } = req.params;
-        return await fastify.core.task.status(taskId);
+        const runtime = await fastify.core.task.status(taskId);
+        return toTaskRuntimeDto(runtime);
     });
     fastify.get("/active", async () => {
-        return await fastify.core.task.listActive();
+        const runtimes = await fastify.core.task.listActive();
+        return runtimes.map(toTaskRuntimeDto);
+    });
+    fastify.get("/report/run/:runId", async (req) => {
+        const { runId } = req.params;
+        return await fastify.core.task.getReportByRunId(runId);
+    });
+    fastify.get("/report/latest/:taskId", async (req) => {
+        const { taskId } = req.params;
+        return await fastify.core.task.getLatestReportByTaskId(taskId);
+    });
+    fastify.get("/report/history/task/:taskId", async (req) => {
+        const { taskId } = req.params;
+        return await fastify.core.task.listReportsByTaskId(taskId, limitFromQuery(req.query));
+    });
+    fastify.get("/report/history/project/:projectId", async (req) => {
+        const { projectId } = req.params;
+        return await fastify.core.task.listReportsByProjectId(projectId, limitFromQuery(req.query));
+    });
+    fastify.get("/report/summary/task/:taskId", async (req) => {
+        const { taskId } = req.params;
+        return await fastify.core.task.listReportSummariesByTaskId(taskId, limitFromQuery(req.query));
+    });
+    fastify.get("/report/summary/project/:projectId", async (req) => {
+        const { projectId } = req.params;
+        return await fastify.core.task.listReportSummariesByProjectId(projectId, limitFromQuery(req.query));
+    });
+    fastify.get("/diagnostics/run/:runId", async (req) => {
+        const { runId } = req.params;
+        return await fastify.core.task.getDiagnosticsByRunId(runId);
+    });
+    fastify.get("/diagnostics/latest/:taskId", async (req) => {
+        const { taskId } = req.params;
+        return await fastify.core.task.getLatestDiagnosticsByTaskId(taskId);
+    });
+    fastify.get("/dashboard/:taskId", async (req) => {
+        const { taskId } = req.params;
+        return await fastify.core.task.getDashboardByTaskId(taskId);
     });
     fastify.get("/log/run/:runId", async (req) => {
         const { runId } = req.params;