@yinuo-ngm/server 1.0.0

package/src/routes/project.routes.ts

@@ -0,0 +1,265 @@
+import { AppError } from "@yinuo-ngm/core";
+import { type FastifyInstance } from "fastify";
+import * as path from "path";
+import { openFolder } from "../common/editor";
+
+/**
+ * Project routes
+ */
+export default async function projectRoutes(fastify: FastifyInstance) {
+    /**
+    * 列出所有项目
+    * POST /list
+    */
+    fastify.get("/list", async () => {
+        const projects = await fastify.core.project.list();
+        return projects;
+    });
+
+    /**
+    * 更新项目（编辑）
+    */
+    fastify.post("/update/:id", async (req, reply) => {
+        const { id } = req.params as { id: string };
+        const body = req.body as Partial<{
+            name: string;
+            env: Record<string, string>;
+            scripts: Record<string, string>;
+        }>;
+        try {
+            // 明确禁止修改的字段
+            if ((body as any).root) {
+                reply.code(400);
+                return { message: "root is immutable" };
+            }
+            const updated = await fastify.core.project.update(id, {
+                ...(body.name !== undefined ? { name: body.name } : {}),
+                ...(body.env !== undefined ? { env: body.env } : {}),
+                ...(body.scripts !== undefined ? { scripts: body.scripts } : {}),
+            });
+            return updated;
+        } catch (err) {
+            if (err instanceof Error) {
+                reply.code(400);
+                return { message: err.message };
+            }
+        }
+    });
+
+    /**
+     * 获取项目详情
+     */
+    fastify.get("/getInfo/:id", async (req,) => {
+        const { id } = req.params as { id: string };
+        const project = await fastify.core.project.get(id);
+        return project;
+    });
+
+    /**
+     * 删除项目
+     */
+    fastify.get("/delete/:id", async (req) => {
+        const { id } = req.params as { id: string };
+        await fastify.core.project.remove(id);
+        return { id };
+    });
+
+    /**
+     * 检查路径是否合法 / 是否已存在项目
+     */
+    fastify.post("/check", async (req) => {
+        const body = req.body as { rootPath: string };
+        return fastify.core.project.checkRoot(body.rootPath);
+    });
+
+    /**
+     * 扫描项目（只读）
+     * POST /detect
+     */
+    fastify.post("/detect", async (req) => {
+        const body = req.body as { rootPath: string };
+        const root = path.resolve(body.rootPath);
+
+        // 直接复用 core.project.scan
+        const meta = await fastify.core.project.scan(root);
+
+        return {
+            framework: meta.framework ?? "unknown",
+            hasPackageJson: !!meta.scripts && Object.keys(meta.scripts).length > 0,
+            scripts: meta.scripts ?? {},
+            recommendedScript:
+                meta.scripts?.dev
+                    ? "dev"
+                    : meta.scripts?.start
+                        ? "start"
+                        : Object.keys(meta.scripts ?? {})[0],
+            hasGit: meta.hasGit ?? false,
+        };
+    });
+
+    /**
+     * 导入已有项目
+     */
+    fastify.post("/import", async (req) => {
+        const body = req.body as {
+            root: string;
+            name?: string;
+            syncTasks?: boolean;
+        };
+        const project = await fastify.core.project.importProject({
+            root: body.root,
+            name: body.name,
+        });
+        // 要自动 sync task，这里加
+        if (body.syncTasks === true) {
+            await fastify.core.task.refreshByProject(project.id);
+        }
+        return {
+            id: project.id,
+        };
+    });
+
+    /**
+     * 检查 root 是否是一个可导入的项目
+     */
+    fastify.post("/checkImport", async (req) => {
+        const body = req.body as { root: string };
+        return fastify.core.project.checkImport(body.root);
+    });
+
+    /**
+     * 创建新项目（暂不接 scaffold） 
+     */
+    fastify.post("/create", async (req) => {
+        // const body = req.body as {
+        //     name: string;
+        //     root: string;
+        //     scripts?: Record<string, string>;
+        //     syncTasks?: boolean;
+        // };
+
+        // const chk = await fastify.core.project.checkRoot(body.root);
+        // if (!chk.ok) return chk;
+
+        // const project = await fastify.core.project.create({
+        //     name: body.name,
+        //     root: chk.root,
+        //     scripts: body.scripts,
+        // });
+
+        // let syncedSpecs: any[] | undefined;
+        // if (body.syncTasks === true) {
+        //     syncedSpecs = await fastify.core.task.syncSpecsFromProjectScripts(
+        //         project.id,
+        //         project.root,
+        //         project.scripts ?? {}
+        //     );
+        // }
+        // return { id: project.id, syncedSpecs };
+        const body = req.body as {
+            name: string;
+            root: string;
+        };
+        const project = await fastify.core.project.create({
+            name: body.name,
+            root: body.root,
+        });
+        return { id: project.id };
+    });
+
+
+    /**
+     * 设置收藏
+     * POST /projects/favorite/:id
+     * body: { isFavorite: boolean }
+     */
+    fastify.post("/favorite/:id", async (req, reply) => {
+        const { id } = req.params as { id: string };
+        const body = req.body as { isFavorite?: boolean };
+        if (typeof body?.isFavorite !== "boolean") {
+            reply.code(400);
+            return { message: "isFavorite must be boolean" };
+        }
+        const updated = await fastify.core.project.setFavorite(id, body.isFavorite);
+        return updated;
+    });
+
+    /**
+     * 切换收藏
+     * POST /projects/favorite/:id/toggle
+     */
+    fastify.post("/favorite/:id/toggle", async (req) => {
+        const { id } = req.params as { id: string };
+        const updated = await fastify.core.project.toggleFavorite(id);
+        return updated;
+    });
+
+    fastify.post("/lastOpened/:id", async (req) => {
+        const { id } = req.params as { id: string };
+        const body = req.body as { timestamp: number };
+        if (typeof body?.timestamp !== "number") {
+            throw new AppError("INVALID_TIMESTAMP", "timestamp must be a number");
+        }
+        const updated = await fastify.core.project.setLastOpened(id, body.timestamp);
+        return updated;
+    });
+
+    fastify.post("/rename/:id", async (req) => {
+        const { id } = req.params as { id: string };
+        const body = req.body as { name: string };
+        if (typeof body?.name !== "string" || body.name.trim() === "") {
+            throw new AppError("INVALID_NAME", "name must be a non-empty string");
+        }
+        const updated = await fastify.core.project.rename(id, body.name.trim());
+        return updated;
+    })
+    fastify.post("/edit/:id", async (req) => {
+        const { id } = req.params as { id: string };
+        const body = req.body as { name: string; description?: string; repoPageUrl?: string; };
+        if (typeof body?.name !== "string" || body.name.trim() === "") {
+            throw new 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() });
+        return updated;
+    })
+
+
+    /**
+     * 在编辑器打开项目
+     * POST /projects/openInEditor/:id
+     * body: { editor?: "code" | "system" }
+     */
+    fastify.post("/openInEditor/:id", async (req) => {
+        try {
+            const { id } = req.params as { id: string };
+            const body = req.body as { editor?: "code" | "system" };
+            const p = await fastify.core.project.get(id);
+            const editor = body?.editor || "code";
+            await openFolder(p.root, { editor });
+            return { ok: true };
+        } catch (e: any) {
+            throw new AppError("EDITOR_LAUNCH_FAILED", e?.message || "openInEditor failed");
+        }
+    });
+
+    fastify.post("/bootstrap/cli", async (req) => {
+        const body = req.body as any;
+        return await fastify.core.bootstrap.bootstrapByCli(body);
+    });
+
+    fastify.post("/bootstrap/git", async (req) => {
+        const body = req.body as any;
+        return await fastify.core.bootstrap.bootstrapByGit(body);
+    });
+
+    fastify.post("/bootstrap/pickRoot", async (req) => {
+        const body = req.body as any;
+        const taskId = String(body?.taskId ?? "").trim();
+        const pickedRoot = String(body?.pickedRoot ?? "").trim();
+        if (!taskId) throw new AppError("BAD_REQUEST", "taskId is required");
+        if (!pickedRoot) throw new AppError("BAD_REQUEST", "pickedRoot is required");
+        const r = await fastify.core.bootstrap.pickWorkspaceRoot({ taskId, pickedRoot });
+        return r;
+    });
+}
+

package/src/routes/rss.routes.ts

@@ -0,0 +1,58 @@
+import { AppError } from "@yinuo-ngm/core";
+import type { FastifyInstance } from "fastify";
+import Parser from "rss-parser";
+
+type CacheEntry = { expireAt: number; payload: any };
+const cache = new Map<string, CacheEntry>();
+
+const parser = new Parser({
+    timeout: 15000, // 15s
+});
+export default async function rssRoutes(app: FastifyInstance) {
+    app.get("/preview", async (req) => {
+        const q = req.query as { url?: string; limit?: string; force?: string; cacheSec?: string };
+        const url = (q.url ?? "").trim();
+        if (!url) {
+            //  return reply.code(400).send({ ok: false, message: "url required" });
+            throw new AppError("INVALID_RSS_URL", "url required", { query: q });
+        }
+        // limit between 1 and 100, default 20
+        const limit = Math.min(Math.max(parseInt(q.limit ?? "20", 10) || 20, 1), 100);
+        // force fetch, default false
+        const force = (q.force ?? "0") === "1";
+        // cache duration between 30 and 3600 seconds, default 2400
+        const cacheSec = Math.min(Math.max(parseInt(q.cacheSec ?? "2400", 10) || 2400, 30), 3600);
+        const key = `${url}|${limit}`;
+        const now = Date.now();
+        if (!force) {
+            const hit = cache.get(key);
+            if (hit && hit.expireAt > now) return hit.payload;
+        }
+        try {
+            const feed = await parser.parseURL(url);
+            const items = (feed.items ?? []).slice(0, limit).map((it) => ({
+                title: it.title ?? "",
+                link: (it.link ?? it.guid ?? "").toString(),
+                pubDate: it.isoDate ?? (it.pubDate ? new Date(it.pubDate).toISOString() : undefined),
+                author: (it.creator ?? it.author ?? "")?.toString() || undefined,
+                summary: (it.contentSnippet ?? it.content ?? "")?.toString() || undefined,
+            }));
+            const payload = {
+                title: feed.title,
+                description: feed.description,
+                link: feed.link,
+                items,
+                fetchedAt: new Date().toISOString(),
+            };
+            cache.set(key, { expireAt: now + cacheSec * 1000, payload });
+            return payload;
+        } catch (e: any) {
+            // return reply.code(500).send({
+            //     ok: false,
+            //     message: "RSS_FETCH_FAILED",
+            //     detail: e?.message || String(e),
+            // });
+            throw new AppError(`RSS_FETCH_FAILED`, e?.message || String(e), { url });
+        }
+    });
+}

package/src/routes/system.routes.ts

@@ -0,0 +1,32 @@
+import type { FastifyInstance } from "fastify";
+import { env } from "../env";
+
+export default async function systemRoutes(fastify: FastifyInstance) {
+  fastify.get("/health", async () => (
+    {
+      ts: Date.now(),
+      name: "ngm-server",
+      pid: process.pid,
+      uptime: process.uptime(),
+      version: process.env.npm_package_version,
+      dataDir: env.dataDir
+    }
+  ));
+
+  fastify.post("/shutdown", async () => {
+    fastify.log.info("Shutdown requested via /shutdown");
+
+    // 异步关闭，避免阻塞响应
+    setTimeout(async () => {
+      try {
+        await fastify.close(); // ← 会触发 onClose
+        process.exit(0);
+      } catch (e) {
+        console.error("Graceful shutdown failed", e);
+        process.exit(1);
+      }
+    }, 50);
+
+    return { ok: true };
+  });
+}

package/src/routes/task.routes.ts

@@ -0,0 +1,85 @@
+import { AppError } from "@yinuo-ngm/core";
+import type { FastifyInstance } from "fastify";
+/** 判断该项目是否已有 specs（用于懒加载） */
+async function ensureSpecs(fastify: FastifyInstance, projectId: string) {
+    const specs = await fastify.core.task.listSpecsByProject(projectId);
+    if (specs.length === 0) {
+        await fastify.core.task.refreshByProject(projectId);
+    }
+}
+
+export default async function taskRoutes(fastify: FastifyInstance) {
+
+    /**
+     * 获取 task views（spec + runtime 聚合）
+     * 懒加载，如果该项目未 refresh 过则自动 refresh
+     * GET /views/:projectId
+     */
+    fastify.get("/list/:projectId", async (req) => {
+        const { projectId } = req.params as { projectId: string };
+        await ensureSpecs(fastify, projectId);
+        return fastify.core.task.listViewsByProject(projectId);
+    });
+
+    /**
+     * 刷新（从 ProjectService.get(projectId) 的 scripts 重新生成 specs）
+     * 返回 views，前端可直接渲染
+     * POST /refresh/:projectId
+     */
+    fastify.post("/refresh/:projectId", async (req) => {
+        const { projectId } = req.params as { projectId: string };
+        // refreshByProject 内部会从 ProjectService.get() 拉 root/scripts/pm 并更新 specs
+        return await fastify.core.task.refreshByProject(projectId);
+    });
+
+    /**
+     * 启动任务（唯一方式）
+     * POST /start
+     * body: { taskId: string } 
+     */
+    fastify.post("/start", async (req) => {
+        const body = req.body as { taskId?: string };
+        const taskId = body?.taskId?.trim();
+        if (!taskId) throw new AppError("TASK_ID_REQUIRED", "taskId is required", { body });
+        return await fastify.core.task.start(taskId);
+    });
+
+
+    /**
+     * 停止任务
+     * POST /stop
+     * body: { taskId: string } 
+     */
+    fastify.post("/stop", async (req) => {
+        const body = req.body as { taskId?: string };
+        const taskId = body?.taskId?.trim();
+        if (!taskId) throw new AppError("TASK_ID_REQUIRED", "taskId is required", { body });
+        return await fastify.core.task.stop(taskId);
+    });
+
+    /**
+     * 查询任务状态
+     * GET /status/:taskId  
+     */
+    fastify.get("/status/:taskId", async (req) => {
+        const { taskId } = req.params as { taskId: string };
+        return await fastify.core.task.status(taskId);
+    });
+
+    /** 列出所有活跃的任务（running / stopping） */
+    fastify.get("/active", async () => {
+        return await fastify.core.task.listActive();
+    });
+
+    /**
+     * 拉取某次运行的任务日志
+     * GET /log/run/:runId?tail=200
+     */
+    fastify.get("/log/run/:runId", async (req) => {
+        const { runId } = req.params as { runId: string };
+        const { tail } = req.query as { tail?: string };
+        const limit = Math.min(Math.max(Number(tail) || 200, 1), 5000);
+        return await fastify.core.task.getTailLogsByRun(runId, limit);
+    });
+}
+

package/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "rootDir": "src",
+    "outDir": "lib",
+    "baseUrl": ".",
+    "paths": {
+      "@core": ["core/src/index.ts"],
+      "@core/*": ["core/src/*"]
+    }
+  },
+  "references": [{ "path": "../core" }]
+}