@yinuo-ngm/server 1.0.0

package/src/plugins/ws/topics/task.ws.ts

@@ -0,0 +1,96 @@
+import type { WsClientMsg, WsServerMsg, TaskEventPayloadMap, TaskEventType, TaskOutputPayload, TaskOutputMsg, TaskEventMsg, LogLine, TaskRuntime } from "@yinuo-ngm/core";
+import { WsContext } from "../ws.context";
+import type { TopicHandler } from "../ws.router";
+
+const keyOfTask = (taskId: string) => `task:${taskId}`;
+
+export type TaskWsDeps = {
+    getTaskSnapshotByTaskId?: (taskId: string) => Promise<TaskRuntime | null>;
+    getTaskTailLogsByRun?: (runId: string, tail: number) => Promise<LogLine[]>;
+    resizeRun?: (taskId: string, cols: number, rows: number) => void;
+};
+
+export function createTaskTopicHandler(
+    deps: TaskWsDeps,
+    getAllClients: () => Iterable<WsContext>
+): TopicHandler & {
+    pushOutput(payload: TaskOutputPayload): void;
+    pushEvent<K extends TaskEventType>(type: K, payload: TaskEventPayloadMap[K]): void;
+} {
+    return {
+        topic: "task",
+        async sub(ctx, msg: Extract<WsClientMsg, { op: "sub"; topic: "task" }>) {
+            const taskId = String(msg?.taskId ?? "").trim();
+            const tail = Number(msg?.tail ?? 0);
+
+            if (!taskId) {
+                ctx.send({ op: "error", code: "TASK_ID_REQUIRED", message: "taskId is required", ts: Date.now() });
+                return;
+            }
+            ctx.addSub("task", keyOfTask(taskId));
+
+            // snapshot：按 taskId
+            let snap: TaskRuntime | undefined
+            if (deps.getTaskSnapshotByTaskId) {
+                snap = await deps.getTaskSnapshotByTaskId(taskId) ?? undefined;
+                if (snap) {
+                    const m: WsServerMsg = {
+                        op: "task.event",
+                        type: "snapshot",
+                        payload: snap,
+                        ts: Date.now(),
+                    };
+                    ctx.send(m);
+                }
+            }
+
+            // tail logs : 按 runId 去拉
+            if (snap?.runId && deps.getTaskTailLogsByRun && tail > 0) {
+                const entries = await deps.getTaskTailLogsByRun(snap.runId, tail);
+                for (const e of entries ?? []) {
+                    const m: TaskOutputMsg = {
+                        op: "task.output",
+                        payload: {
+                            taskId: taskId,
+                            runId: snap.runId,
+                            stream: (e?.level === "warn" || e?.level === "error") ? "stderr" : "stdout",
+                            text: String(e?.text ?? ""),
+                        },
+                        ts: e?.ts ?? Date.now(),
+                    };
+                    ctx.send(m);
+                }
+            }
+        },
+        // resize
+        resize(ctx, msg: Extract<WsClientMsg, { op: "resize" }>) {
+            const taskId = (msg as any).taskId as string;
+            const cols = Number((msg as any).cols);
+            const rows = Number((msg as any).rows);
+            if (!taskId || !Number.isFinite(cols) || !Number.isFinite(rows)) return;
+
+            // 最小值
+            const c = Math.max(2, Math.floor(cols));
+            const r = Math.max(1, Math.floor(rows));
+
+            deps.resizeRun?.(taskId, c, r);
+        },
+
+        unsub(ctx, msg: Extract<WsClientMsg, { op: "unsub"; topic: "task" }>) {
+            const taskId = String(msg?.taskId ?? "").trim();
+            if (!taskId) return;
+            ctx.delSub("task", keyOfTask(taskId));
+        },
+
+        pushOutput(payload: TaskOutputPayload) {
+            const m: TaskOutputMsg = { op: "task.output", payload, ts: Date.now() };
+            for (const c of getAllClients()) if (c.hasSub("task", keyOfTask(payload.taskId))) c.send(m);
+        },
+
+        pushEvent<K extends TaskEventType>(type: K, payload: TaskEventPayloadMap[K]) {
+            const m: WsServerMsg = { op: "task.event", type, payload, ts: Date.now() } as TaskEventMsg;
+            for (const c of getAllClients()) if (c.hasSub("task", keyOfTask(payload.taskId))) c.send(m);
+
+        },
+    };
+}

package/src/plugins/ws/ws.context.ts

@@ -0,0 +1,32 @@
+import type { WsServerMsg, WsTopic } from "@yinuo-ngm/core";
+export class WsContext {
+    readonly connId: string;
+    private subs = new Map<WsTopic, Set<string>>();
+
+    constructor(connId: string, private socket: WebSocket) {
+        this.connId = connId;
+    }
+
+    send(msg: WsServerMsg) {
+        if (this.socket.readyState !== this.socket.OPEN) return;
+        this.socket.send(JSON.stringify(msg));
+    }
+
+    addSub(topic: WsTopic, key: string) {
+        const set = this.subs.get(topic) ?? new Set<string>();
+        set.add(key);
+        this.subs.set(topic, set);
+    }
+    delSub(topic: WsTopic, key: string) {
+        const set = this.subs.get(topic);
+        if (!set) return;
+        set.delete(key);
+        if (set.size === 0) this.subs.delete(topic);
+    }
+    hasSub(topic: WsTopic, key: string) {
+        return this.subs.get(topic)?.has(key) ?? false;
+    }
+    clearAll() {
+        this.subs.clear();
+    }
+}

package/src/plugins/ws/ws.plugin.ts

@@ -0,0 +1,103 @@
+// server/src/plugins/ws/ws.plugin.ts
+import { Events } from "@yinuo-ngm/core";
+import websocket from "@fastify/websocket";
+import type { FastifyInstance } from "fastify";
+import fp from "fastify-plugin";
+import { createTaskTopicHandler } from "./topics";
+import { createSyslogTopicHandler } from "./topics/syslog.ws";
+import { WsContext } from "./ws.context";
+import { WsRouter } from "./ws.router";
+
+function uid() {
+    return Math.random().toString(16).slice(2) + Date.now().toString(16);
+}
+
+export default fp(async function wsPlugin(fastify: FastifyInstance) {
+
+    await fastify.register(websocket);
+
+    const clients = new Map<string, WsContext>();
+
+    const router = new WsRouter();
+
+    // 注册 topics： core.task 的能力注入进来
+    const taskHandler = createTaskTopicHandler(
+        {
+            getTaskSnapshotByTaskId: (taskId) => fastify.core.task.getSnapshotByTaskId(taskId),
+            getTaskTailLogsByRun: (runId, tail) => fastify.core.task.getTailLogsByRun(runId, tail),
+            resizeRun: (taskId, cols, rows) => fastify.core.task.resizeRun(taskId, cols, rows),
+        },
+        () => clients.values()
+    );
+    router.register(taskHandler);
+
+    // syslog
+    const syslogHandler = createSyslogTopicHandler(
+        { getSyslogTail: (tail) => fastify.core.sysLog.tail(tail) },
+        () => clients.values()
+    );
+    router.register(syslogHandler);
+
+
+    // 事件订阅：拿到 disposer，onClose 释放
+    const offs: Array<() => void> = [];
+
+    offs.push(fastify.core.events.on(Events.TASK_OUTPUT, (e) => {
+        taskHandler.pushOutput(e);
+    }));
+
+    offs.push(fastify.core.events.on(Events.TASK_STARTED, (e) => {
+        taskHandler.pushEvent("started", e);
+    }));
+
+    offs.push(fastify.core.events.on(Events.TASK_STOP_REQUESTED, (e) => {
+        taskHandler.pushEvent("stopRequested", e);
+    }));
+
+    offs.push(fastify.core.events.on(Events.TASK_EXITED, (e) => {
+        taskHandler.pushEvent("exited", e);
+    }));
+
+    offs.push(fastify.core.events.on(Events.TASK_FAILED, (e) => {
+        taskHandler.pushEvent("failed", e);
+    }));
+
+    offs.push(fastify.core.events.on(Events.SYSLOG_APPENDED, (e) => {
+        syslogHandler.push(e.entry);
+    }));
+
+    offs.push(fastify.core.events.on(Events.PROJECT_BOOTSTRAP_DONE, (e) => {
+        taskHandler.pushEvent("bootstrapDone", e);
+    }))
+
+    offs.push(fastify.core.events.on(Events.PROJECT_BOOTSTRAP_FAILED, (e) => {
+        taskHandler.pushEvent("bootstrapFailed", e);
+    }))
+
+    offs.push(fastify.core.events.on(Events.PROJECT_BOOTSTRAP_NEED_PICK_ROOT, (e) => {
+        taskHandler.pushEvent("bootstrapNeedPickRoot", e);
+    }))
+
+
+    fastify.addHook("onClose", async () => {
+        // 防止 dev 热重载 / 反复 register 导致重复推送
+        offs.forEach((off) => {
+            try { off(); } catch { }
+        });
+        clients.clear();
+    });
+
+    fastify.get("/ws", { websocket: true }, (ws) => {
+        const connId = uid();
+        const ctx = new WsContext(connId, ws);
+        // console.log("[ws] open", connId, "clients=", clients.size + 1);
+        clients.set(connId, ctx);
+        ctx.send({ op: "hello", connId, ts: Date.now() });
+        // 接收client消息
+        ws.on("message", (data: any) => router.handleRaw(ctx, data));
+        ws.on("close", () => {
+            ctx.clearAll();
+            clients.delete(connId);
+        });
+    });
+});

package/src/plugins/ws/ws.router.ts

@@ -0,0 +1,79 @@
+import { WsClientMsg, WsServerMsg, WsTopic, ErrorCode } from "@yinuo-ngm/core";
+import { WsContext } from "./ws.context";
+
+export type TopicHandler = {
+    topic: WsTopic;
+    sub(ctx: WsContext, msg: Extract<WsClientMsg, { op: "sub" }>): Promise<void> | void;
+    unsub(ctx: WsContext, msg: Extract<WsClientMsg, { op: "unsub" }>): Promise<void> | void;
+
+    resize?(ctx: WsContext, msg: Extract<WsClientMsg, { op: "resize" }>): Promise<void> | void;
+};
+
+export class WsRouter {
+    private handlers = new Map<WsTopic, TopicHandler>();
+
+    register(handler: TopicHandler) {
+        this.handlers.set(handler.topic, handler);
+    }
+
+    handleRaw(ctx: WsContext, raw: any) {
+        let msg: WsClientMsg | null = null;
+        // console.log("[ws] recv", ctx.connId, raw);
+        try {
+            const text = typeof raw === "string" ? raw : raw?.toString?.() ?? "";
+            msg = JSON.parse(text);
+        } catch {
+            ctx.send(this.err("BAD_JSON", "Invalid JSON"));
+            return;
+        }
+
+        if (!msg || typeof msg !== "object" || !("op" in msg)) {
+            ctx.send(this.err("BAD_MSG", "Invalid message"));
+            return;
+        }
+
+        if (msg.op === "ping") {
+            ctx.send({ op: "pong", ts: Date.now() });
+            return;
+        }
+
+        // resize
+        if (msg.op === "resize") {
+            const topic = (msg as Extract<WsClientMsg, { op: "resize" }>).topic as WsTopic;
+            const h = this.handlers.get(topic);
+            if (!h || !h.resize) {
+                ctx.send(this.err("OP_NOT_SUPPORTED", `resize not supported on topic: ${String(topic)}`, { topic }));
+                return;
+            }
+            try {
+                return void h.resize(ctx, msg as any);
+            } catch (e: any) {
+                ctx.send(this.err("HANDLER_FAILED", e?.message ?? "handler failed", { topic, op: msg.op }));
+                return;
+            }
+        }
+
+
+        if (msg.op === "sub" || msg.op === "unsub") {
+            const topic = (msg as Extract<WsClientMsg, { op: "sub" | "unsub" }>).topic as WsTopic;
+            const h = this.handlers.get(topic);
+            if (!h) {
+                ctx.send(this.err("TOPIC_NOT_FOUND", `Unknown topic: ${String(topic)}`, { topic }));
+                return;
+            }
+            try {
+                if (msg.op === "sub") return void h.sub(ctx, msg as any);
+                return void h.unsub(ctx, msg as any);
+            } catch (e: any) {
+                ctx.send(this.err("HANDLER_FAILED", e?.message ?? "handler failed", { topic, op: msg.op }));
+            }
+            return;
+        }
+
+        ctx.send(this.err("OP_NOT_FOUND", `Unknown op: ${(msg as any).op}`));
+    }
+
+    private err(code: ErrorCode, message: string, details?: any): WsServerMsg {
+        return { op: "error", code, message, details, ts: Date.now() };
+    }
+}

package/src/routes/config.routes.ts

@@ -0,0 +1,86 @@
+import { AppError } from "@yinuo-ngm/core";
+import type { FastifyInstance } from "fastify";
+import { openFolder } from "../common/editor";
+
+export default async function configRoutes(fastify: FastifyInstance) {
+
+    // GET catalog
+    fastify.get("/catalog/:projectId", async (req) => {
+        const { projectId } = req.params as { projectId: string };
+        return await fastify.core.config.getCatalog(projectId);
+    });
+
+    // GET read doc
+    fastify.get("/readDoc/:projectId/:docId", async (req) => {
+        const { projectId, docId } = req.params as { projectId: string; docId: string };
+        return await fastify.core.config.readDoc(projectId, docId);
+    });
+
+    // POST write doc
+    fastify.post("/writeDoc/:projectId/:docId", async (req) => {
+        const { projectId, docId } = req.params as { projectId: string; docId: string };
+        const body = req.body as any;
+
+        // 约定：raw 优先，其次 data
+        const next = body?.raw ?? body?.data;
+        if (next === undefined) {
+            throw new AppError("CONFIG_WRITE_FAILED", "missing body.raw or body.data", { projectId, docId });
+        }
+        return await fastify.core.config.writeDoc(projectId, docId, next);
+    });
+
+    /**
+        * 在编辑器打开项目
+        * POST /projects/openInEditor/:projectId
+        * body: { editor?: "code" | "system" }
+        */
+    fastify.post("/openInEditor/:projectId/:docId", async (req) => {
+        try {
+            const { projectId, docId } = req.params as { projectId: string; docId: string };
+            const { filePath } = await fastify.core.config.openDoc(projectId, docId);
+            await openFolder(filePath, { editor: 'code' });
+            return { ok: true };
+        } catch (e: any) {
+            throw new AppError("EDITOR_LAUNCH_FAILED", e?.message || "openInEditor failed");
+        }
+    });
+
+    // GET read schema
+    fastify.get("/readSchema/:projectId/:domainId", async (req) => {
+        const { projectId, domainId } = req.params as { projectId: string; domainId: string };
+        return await fastify.core.config.readDomainSchema(projectId, domainId);
+    });
+
+    // POST write schema
+    fastify.post("/writeSchema/:projectId/:domainId", async (req) => {
+        const { projectId, domainId } = req.params as { projectId: string; domainId: string };
+        const body = req.body as any;
+        const vm = body?.vm;
+        if (vm === undefined) {
+            throw new AppError("BAD_REQUEST", "missing body.vm");
+        }
+        await fastify.core.config.writeDomainSchema(projectId, domainId, vm);
+        return {
+            projectId,
+            domainId,
+        };
+    });
+
+    // GET domain schema doc
+    fastify.get("/getDomainSchema/:projectId/:domainId", async (req) => {
+        const { projectId, domainId } = req.params as { projectId: string; domainId: string };
+        return await fastify.core.config.getDomainSchemaDoc(projectId, domainId);
+    });
+
+    // POST diff domain schema
+    fastify.post("/diffSchema/:projectId/:domainId", async (req) => {
+        const { projectId, domainId } = req.params as { projectId: string; domainId: string };
+        const body = req.body as any;
+        const vm = body?.vm;
+        if (vm === undefined) {
+            throw new AppError("BAD_REQUEST", "missing body.vm");
+        }
+        return await fastify.core.config.diffDomainSchema(projectId, domainId, vm);
+    });
+
+}

package/src/routes/dashboard.routes.ts

@@ -0,0 +1,43 @@
+import type { DashboardDocV1 } from "@yinuo-ngm/core";
+import type { FastifyInstance } from "fastify";
+
+export default async function dashboardRoutes(fastify: FastifyInstance) {
+    // GET /dashboard/:projectId
+    fastify.get("/getInfo/:projectId", async (req,) => {
+        const { projectId } = req.params as any;
+        return await fastify.core.dashboard.getOrCreate(projectId);
+    });
+
+    // post /dashboard/update/:projectId
+    fastify.post("/update/:projectId", async (req,) => {
+        const { projectId } = req.params as any;
+        const body = req.body as DashboardDocV1;
+        return await fastify.core.dashboard.saveWithConflictCheck(projectId, body);
+    });
+
+    // post /dashboard/widgets
+    fastify.get("/widgets/:projectId", async (req,) => {
+        const { projectId } = req.params as any;
+        return await fastify.core.dashboard.getAvailableWidgets(projectId);
+    });
+
+    // post /dashboard/widgets/:projectId
+    fastify.get("/addWidget/:projectId/:widgetKey/:x/:y", async (req,) => {
+        let { projectId, widgetKey, x, y } = req.params as any;
+        x = Number(x) || 0;
+        y = Number(y) || 0;
+        return await fastify.core.dashboard.addWidget(projectId, widgetKey, x, y);
+    });
+
+    // delete /dashboard/widgets/:projectId/:widgetKey
+    fastify.get("/removeWidget/:projectId/:widgetId", async (req,) => {
+        const { projectId, widgetId } = req.params as any;
+        return await fastify.core.dashboard.removeWidget(projectId, widgetId);
+    });
+
+    fastify.post("/updateItemConfig/:projectId/:widgetId", async (req,) => {
+        const { projectId, widgetId } = req.params as any;
+        const config = req.body as any;
+        return await fastify.core.dashboard.updateItemConfig(projectId, widgetId, config);
+    });
+}

package/src/routes/deps.route.ts

@@ -0,0 +1,51 @@
+import type { FastifyInstance } from "fastify";
+
+export default async function depsRoutes(fastify: FastifyInstance) {
+
+    fastify.get("/list/:projectId", async (req) => {
+        const { projectId } = req.params as any;
+        const data = await fastify.core.deps.list(projectId);
+        return data;
+    });
+
+    fastify.post("/install/:projectId", async (req) => {
+        const { projectId } = req.params as any;
+        const body = req.body as {
+            name: string;
+            group: "dependencies" | "devDependencies";
+            target: "required" | "latest" | "custom";
+            version?: string;
+        };
+
+        await fastify.core.deps.install(projectId, body);
+        return { ok: true };
+    });
+
+    fastify.post("/uninstall/:projectId", async (req) => {
+        const { projectId } = req.params as any;
+        const body = req.body as {
+            name: string;
+            group: "dependencies" | "devDependencies";
+        };
+
+        await fastify.core.deps.uninstall(projectId, body);
+        return { ok: true };
+    });
+
+    fastify.post("/devtools/install/:projectId", async (req) => {
+        // // 先给最小实现：安装一组推荐包（可按需要改）
+        // const { projectId } = req.params as any;
+        // const project = await fastify.core.project.get(projectId);
+
+        // // 举例：eslint/prettier（也可以换成你自己的 devtools 集合）
+        // const pkgs = ["eslint", "prettier"];
+        // for (const name of pkgs) {
+        //     await fastify.core.deps.install(projectId, {
+        //         name,
+        //         group: "devDependencies",
+        //         target: "latest",
+        //     });
+        // }
+        return { ok: true };
+    });
+}

package/src/routes/fs.routes.ts

@@ -0,0 +1,31 @@
+import type { FastifyInstance } from "fastify";
+import path from "node:path";
+
+export default async function fsRoutes(fastify: FastifyInstance) {
+
+    fastify.get("/ls", async (req) => {
+        const q = req.query as { path?: string; showSystem?: "0" | "1" | boolean };
+
+        const showSystem =
+            q.showSystem === "1" || q.showSystem === true || q.showSystem === ("true" as any);
+
+        return fastify.core.fs.ls(q.path || "", { showSystem, detectProject: true, detectConcurrency: 8 });
+    });
+
+    fastify.post("/mkdir", async (req) => {
+        const body = req.body as { path?: string; name?: string };
+        return fastify.core.fs.mkdir(body?.path || "", body?.name || "", {
+            recursive: true, // 默认支持多级创建
+        });
+    });
+
+    fastify.get("/path-exists", async (req) => {
+        const q = req.query as { path?: string };
+        const raw = String(q?.path ?? "").trim();
+        if (!raw) return { exists: false };
+        // 规范化一下，避免奇怪的相对路径
+        const p = path.resolve(raw);
+        const exists = await fastify.core.fs.exists(p);
+        return { exists };
+    });
+}

package/src/routes/index.ts

@@ -0,0 +1,19 @@
+import configRoutes from './config.routes';
+import dashboardRoutes from './dashboard.routes';
+import depsRoutes from './deps.route';
+import fsRoutes from './fs.routes';
+import projectRoutes from './project.routes';
+import rssRoutes from './rss.routes';
+import systemRoutes from './system.routes';
+import taskRoutes from './task.routes';
+
+export {
+    configRoutes,
+    depsRoutes,
+    fsRoutes,
+    projectRoutes,
+    systemRoutes,
+    taskRoutes,
+    dashboardRoutes,
+    rssRoutes,
+};