@yinuo-ngm/server 1.0.0

package/lib/plugins/ws/ws.context.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WsContext = void 0;
+class WsContext {
+    constructor(connId, socket) {
+        this.socket = socket;
+        this.subs = new Map();
+        this.connId = connId;
+    }
+    send(msg) {
+        if (this.socket.readyState !== this.socket.OPEN)
+            return;
+        this.socket.send(JSON.stringify(msg));
+    }
+    addSub(topic, key) {
+        const set = this.subs.get(topic) ?? new Set();
+        set.add(key);
+        this.subs.set(topic, set);
+    }
+    delSub(topic, key) {
+        const set = this.subs.get(topic);
+        if (!set)
+            return;
+        set.delete(key);
+        if (set.size === 0)
+            this.subs.delete(topic);
+    }
+    hasSub(topic, key) {
+        return this.subs.get(topic)?.has(key) ?? false;
+    }
+    clearAll() {
+        this.subs.clear();
+    }
+}
+exports.WsContext = WsContext;

package/lib/plugins/ws/ws.plugin.d.ts

@@ -0,0 +1,3 @@
+import type { FastifyInstance } from "fastify";
+declare const _default: (fastify: FastifyInstance) => Promise<void>;
+export default _default;

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

@@ -0,0 +1,76 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+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() {
+    return Math.random().toString(16).slice(2) + Date.now().toString(16);
+}
+exports.default = (0, fastify_plugin_1.default)(async function wsPlugin(fastify) {
+    await fastify.register(websocket_1.default);
+    const clients = new Map();
+    const router = new ws_router_1.WsRouter();
+    const taskHandler = (0, topics_1.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);
+    const syslogHandler = (0, syslog_ws_1.createSyslogTopicHandler)({ getSyslogTail: (tail) => fastify.core.sysLog.tail(tail) }, () => clients.values());
+    router.register(syslogHandler);
+    const offs = [];
+    offs.push(fastify.core.events.on(core_1.Events.TASK_OUTPUT, (e) => {
+        taskHandler.pushOutput(e);
+    }));
+    offs.push(fastify.core.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) => {
+        taskHandler.pushEvent("stopRequested", e);
+    }));
+    offs.push(fastify.core.events.on(core_1.Events.TASK_EXITED, (e) => {
+        taskHandler.pushEvent("exited", e);
+    }));
+    offs.push(fastify.core.events.on(core_1.Events.TASK_FAILED, (e) => {
+        taskHandler.pushEvent("failed", e);
+    }));
+    offs.push(fastify.core.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) => {
+        taskHandler.pushEvent("bootstrapDone", e);
+    }));
+    offs.push(fastify.core.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) => {
+        taskHandler.pushEvent("bootstrapNeedPickRoot", e);
+    }));
+    fastify.addHook("onClose", async () => {
+        offs.forEach((off) => {
+            try {
+                off();
+            }
+            catch { }
+        });
+        clients.clear();
+    });
+    fastify.get("/ws", { websocket: true }, (ws) => {
+        const connId = uid();
+        const ctx = new ws_context_1.WsContext(connId, ws);
+        clients.set(connId, ctx);
+        ctx.send({ op: "hello", connId, ts: Date.now() });
+        ws.on("message", (data) => router.handleRaw(ctx, data));
+        ws.on("close", () => {
+            ctx.clearAll();
+            clients.delete(connId);
+        });
+    });
+});

package/lib/plugins/ws/ws.router.d.ts

@@ -0,0 +1,20 @@
+import { WsClientMsg, WsTopic } 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 declare class WsRouter {
+    private handlers;
+    register(handler: TopicHandler): void;
+    handleRaw(ctx: WsContext, raw: any): undefined;
+    private err;
+}

package/lib/plugins/ws/ws.router.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WsRouter = void 0;
+class WsRouter {
+    constructor() {
+        this.handlers = new Map();
+    }
+    register(handler) {
+        this.handlers.set(handler.topic, handler);
+    }
+    handleRaw(ctx, raw) {
+        let msg = null;
+        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;
+        }
+        if (msg.op === "resize") {
+            const topic = msg.topic;
+            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);
+            }
+            catch (e) {
+                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.topic;
+            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);
+                return void h.unsub(ctx, msg);
+            }
+            catch (e) {
+                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.op}`));
+    }
+    err(code, message, details) {
+        return { op: "error", code, message, details, ts: Date.now() };
+    }
+}
+exports.WsRouter = WsRouter;

package/lib/routes/config.routes.d.ts

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

package/lib/routes/config.routes.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = configRoutes;
+const core_1 = require("@yinuo-ngm/core");
+const editor_1 = require("../common/editor");
+async function configRoutes(fastify) {
+    fastify.get("/catalog/:projectId", async (req) => {
+        const { projectId } = req.params;
+        return await fastify.core.config.getCatalog(projectId);
+    });
+    fastify.get("/readDoc/:projectId/:docId", async (req) => {
+        const { projectId, docId } = req.params;
+        return await fastify.core.config.readDoc(projectId, docId);
+    });
+    fastify.post("/writeDoc/:projectId/:docId", async (req) => {
+        const { projectId, docId } = req.params;
+        const body = req.body;
+        const next = body?.raw ?? body?.data;
+        if (next === undefined) {
+            throw new core_1.AppError("CONFIG_WRITE_FAILED", "missing body.raw or body.data", { projectId, docId });
+        }
+        return await fastify.core.config.writeDoc(projectId, docId, next);
+    });
+    fastify.post("/openInEditor/:projectId/:docId", async (req) => {
+        try {
+            const { projectId, docId } = req.params;
+            const { filePath } = await fastify.core.config.openDoc(projectId, docId);
+            await (0, editor_1.openFolder)(filePath, { editor: 'code' });
+            return { ok: true };
+        }
+        catch (e) {
+            throw new core_1.AppError("EDITOR_LAUNCH_FAILED", e?.message || "openInEditor failed");
+        }
+    });
+    fastify.get("/readSchema/:projectId/:domainId", async (req) => {
+        const { projectId, domainId } = req.params;
+        return await fastify.core.config.readDomainSchema(projectId, domainId);
+    });
+    fastify.post("/writeSchema/:projectId/:domainId", async (req) => {
+        const { projectId, domainId } = req.params;
+        const body = req.body;
+        const vm = body?.vm;
+        if (vm === undefined) {
+            throw new core_1.AppError("BAD_REQUEST", "missing body.vm");
+        }
+        await fastify.core.config.writeDomainSchema(projectId, domainId, vm);
+        return {
+            projectId,
+            domainId,
+        };
+    });
+    fastify.get("/getDomainSchema/:projectId/:domainId", async (req) => {
+        const { projectId, domainId } = req.params;
+        return await fastify.core.config.getDomainSchemaDoc(projectId, domainId);
+    });
+    fastify.post("/diffSchema/:projectId/:domainId", async (req) => {
+        const { projectId, domainId } = req.params;
+        const body = req.body;
+        const vm = body?.vm;
+        if (vm === undefined) {
+            throw new core_1.AppError("BAD_REQUEST", "missing body.vm");
+        }
+        return await fastify.core.config.diffDomainSchema(projectId, domainId, vm);
+    });
+}

package/lib/routes/dashboard.routes.d.ts

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

package/lib/routes/dashboard.routes.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = dashboardRoutes;
+async function dashboardRoutes(fastify) {
+    fastify.get("/getInfo/:projectId", async (req) => {
+        const { projectId } = req.params;
+        return await fastify.core.dashboard.getOrCreate(projectId);
+    });
+    fastify.post("/update/:projectId", async (req) => {
+        const { projectId } = req.params;
+        const body = req.body;
+        return await fastify.core.dashboard.saveWithConflictCheck(projectId, body);
+    });
+    fastify.get("/widgets/:projectId", async (req) => {
+        const { projectId } = req.params;
+        return await fastify.core.dashboard.getAvailableWidgets(projectId);
+    });
+    fastify.get("/addWidget/:projectId/:widgetKey/:x/:y", async (req) => {
+        let { projectId, widgetKey, x, y } = req.params;
+        x = Number(x) || 0;
+        y = Number(y) || 0;
+        return await fastify.core.dashboard.addWidget(projectId, widgetKey, x, y);
+    });
+    fastify.get("/removeWidget/:projectId/:widgetId", async (req) => {
+        const { projectId, widgetId } = req.params;
+        return await fastify.core.dashboard.removeWidget(projectId, widgetId);
+    });
+    fastify.post("/updateItemConfig/:projectId/:widgetId", async (req) => {
+        const { projectId, widgetId } = req.params;
+        const config = req.body;
+        return await fastify.core.dashboard.updateItemConfig(projectId, widgetId, config);
+    });
+}

package/lib/routes/deps.route.d.ts

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

package/lib/routes/deps.route.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = depsRoutes;
+async function depsRoutes(fastify) {
+    fastify.get("/list/:projectId", async (req) => {
+        const { projectId } = req.params;
+        const data = await fastify.core.deps.list(projectId);
+        return data;
+    });
+    fastify.post("/install/:projectId", async (req) => {
+        const { projectId } = req.params;
+        const body = req.body;
+        await fastify.core.deps.install(projectId, body);
+        return { ok: true };
+    });
+    fastify.post("/uninstall/:projectId", async (req) => {
+        const { projectId } = req.params;
+        const body = req.body;
+        await fastify.core.deps.uninstall(projectId, body);
+        return { ok: true };
+    });
+    fastify.post("/devtools/install/:projectId", async (req) => {
+        return { ok: true };
+    });
+}

package/lib/routes/fs.routes.d.ts

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

package/lib/routes/fs.routes.js

@@ -0,0 +1,29 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = fsRoutes;
+const node_path_1 = __importDefault(require("node:path"));
+async function fsRoutes(fastify) {
+    fastify.get("/ls", async (req) => {
+        const q = req.query;
+        const showSystem = q.showSystem === "1" || q.showSystem === true || q.showSystem === "true";
+        return fastify.core.fs.ls(q.path || "", { showSystem, detectProject: true, detectConcurrency: 8 });
+    });
+    fastify.post("/mkdir", async (req) => {
+        const body = req.body;
+        return fastify.core.fs.mkdir(body?.path || "", body?.name || "", {
+            recursive: true,
+        });
+    });
+    fastify.get("/path-exists", async (req) => {
+        const q = req.query;
+        const raw = String(q?.path ?? "").trim();
+        if (!raw)
+            return { exists: false };
+        const p = node_path_1.default.resolve(raw);
+        const exists = await fastify.core.fs.exists(p);
+        return { exists };
+    });
+}

package/lib/routes/index.d.ts

@@ -0,0 +1,9 @@
+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, };

package/lib/routes/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rssRoutes = exports.dashboardRoutes = exports.taskRoutes = exports.systemRoutes = exports.projectRoutes = exports.fsRoutes = exports.depsRoutes = exports.configRoutes = void 0;
+const config_routes_1 = __importDefault(require("./config.routes"));
+exports.configRoutes = config_routes_1.default;
+const dashboard_routes_1 = __importDefault(require("./dashboard.routes"));
+exports.dashboardRoutes = dashboard_routes_1.default;
+const deps_route_1 = __importDefault(require("./deps.route"));
+exports.depsRoutes = deps_route_1.default;
+const fs_routes_1 = __importDefault(require("./fs.routes"));
+exports.fsRoutes = fs_routes_1.default;
+const project_routes_1 = __importDefault(require("./project.routes"));
+exports.projectRoutes = project_routes_1.default;
+const rss_routes_1 = __importDefault(require("./rss.routes"));
+exports.rssRoutes = rss_routes_1.default;
+const system_routes_1 = __importDefault(require("./system.routes"));
+exports.systemRoutes = system_routes_1.default;
+const task_routes_1 = __importDefault(require("./task.routes"));
+exports.taskRoutes = task_routes_1.default;

package/lib/routes/project.routes.d.ts

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

package/lib/routes/project.routes.js

@@ -0,0 +1,196 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = projectRoutes;
+const core_1 = require("@yinuo-ngm/core");
+const path = __importStar(require("path"));
+const editor_1 = require("../common/editor");
+async function projectRoutes(fastify) {
+    fastify.get("/list", async () => {
+        const projects = await fastify.core.project.list();
+        return projects;
+    });
+    fastify.post("/update/:id", async (req, reply) => {
+        const { id } = req.params;
+        const body = req.body;
+        try {
+            if (body.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;
+        const project = await fastify.core.project.get(id);
+        return project;
+    });
+    fastify.get("/delete/:id", async (req) => {
+        const { id } = req.params;
+        await fastify.core.project.remove(id);
+        return { id };
+    });
+    fastify.post("/check", async (req) => {
+        const body = req.body;
+        return fastify.core.project.checkRoot(body.rootPath);
+    });
+    fastify.post("/detect", async (req) => {
+        const body = req.body;
+        const root = path.resolve(body.rootPath);
+        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;
+        const project = await fastify.core.project.importProject({
+            root: body.root,
+            name: body.name,
+        });
+        if (body.syncTasks === true) {
+            await fastify.core.task.refreshByProject(project.id);
+        }
+        return {
+            id: project.id,
+        };
+    });
+    fastify.post("/checkImport", async (req) => {
+        const body = req.body;
+        return fastify.core.project.checkImport(body.root);
+    });
+    fastify.post("/create", async (req) => {
+        const body = req.body;
+        const project = await fastify.core.project.create({
+            name: body.name,
+            root: body.root,
+        });
+        return { id: project.id };
+    });
+    fastify.post("/favorite/:id", async (req, reply) => {
+        const { id } = req.params;
+        const body = req.body;
+        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;
+    });
+    fastify.post("/favorite/:id/toggle", async (req) => {
+        const { id } = req.params;
+        const updated = await fastify.core.project.toggleFavorite(id);
+        return updated;
+    });
+    fastify.post("/lastOpened/:id", async (req) => {
+        const { id } = req.params;
+        const body = req.body;
+        if (typeof body?.timestamp !== "number") {
+            throw new core_1.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;
+        const body = req.body;
+        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.rename(id, body.name.trim());
+        return updated;
+    });
+    fastify.post("/edit/:id", async (req) => {
+        const { id } = req.params;
+        const body = req.body;
+        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() });
+        return updated;
+    });
+    fastify.post("/openInEditor/:id", async (req) => {
+        try {
+            const { id } = req.params;
+            const body = req.body;
+            const p = await fastify.core.project.get(id);
+            const editor = body?.editor || "code";
+            await (0, editor_1.openFolder)(p.root, { editor });
+            return { ok: true };
+        }
+        catch (e) {
+            throw new core_1.AppError("EDITOR_LAUNCH_FAILED", e?.message || "openInEditor failed");
+        }
+    });
+    fastify.post("/bootstrap/cli", async (req) => {
+        const body = req.body;
+        return await fastify.core.bootstrap.bootstrapByCli(body);
+    });
+    fastify.post("/bootstrap/git", async (req) => {
+        const body = req.body;
+        return await fastify.core.bootstrap.bootstrapByGit(body);
+    });
+    fastify.post("/bootstrap/pickRoot", async (req) => {
+        const body = req.body;
+        const taskId = String(body?.taskId ?? "").trim();
+        const pickedRoot = String(body?.pickedRoot ?? "").trim();
+        if (!taskId)
+            throw new core_1.AppError("BAD_REQUEST", "taskId is required");
+        if (!pickedRoot)
+            throw new core_1.AppError("BAD_REQUEST", "pickedRoot is required");
+        const r = await fastify.core.bootstrap.pickWorkspaceRoot({ taskId, pickedRoot });
+        return r;
+    });
+}

package/lib/routes/rss.routes.d.ts

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

package/lib/routes/rss.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 = rssRoutes;
+const core_1 = require("@yinuo-ngm/core");
+const rss_parser_1 = __importDefault(require("rss-parser"));
+const cache = new Map();
+const parser = new rss_parser_1.default({
+    timeout: 15000,
+});
+async function rssRoutes(app) {
+    app.get("/preview", async (req) => {
+        const q = req.query;
+        const url = (q.url ?? "").trim();
+        if (!url) {
+            throw new core_1.AppError("INVALID_RSS_URL", "url required", { query: q });
+        }
+        const limit = Math.min(Math.max(parseInt(q.limit ?? "20", 10) || 20, 1), 100);
+        const force = (q.force ?? "0") === "1";
+        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) {
+            throw new core_1.AppError(`RSS_FETCH_FAILED`, e?.message || String(e), { url });
+        }
+    });
+}