taskmeld 0.1.1

package/dist/src/server/api-handler.js

@@ -0,0 +1,163 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createApiHandler = void 0;
+const node_url_1 = require("node:url");
+const http_utils_1 = require("./http-utils");
+const serve_static_1 = require("./serve-static");
+const router_js_1 = require("./router.js");
+const middleware_js_1 = require("./middleware.js");
+const health_js_1 = require("./routes/health.js");
+const gateway_js_1 = require("./routes/gateway.js");
+const timeline_js_1 = require("./routes/timeline.js");
+const logs_js_1 = require("./routes/logs.js");
+const artifacts_js_1 = require("./routes/artifacts.js");
+const agents_js_1 = require("./routes/agents.js");
+const sessions_js_1 = require("./routes/sessions.js");
+const pipelines_js_1 = require("./routes/pipelines.js");
+const pipeline_workflow_js_1 = require("./routes/pipeline-workflow.js");
+const pipeline_runtime_js_1 = require("./routes/pipeline-runtime.js");
+const pipeline_batch_js_1 = require("./routes/pipeline-batch.js");
+const pipeline_scheduler_js_1 = require("./routes/pipeline-scheduler.js");
+const pipeline_diagnostics_js_1 = require("./routes/pipeline-diagnostics.js");
+const pipeline_outputs_js_1 = require("./routes/pipeline-outputs.js");
+const pipeline_links_js_1 = require("./routes/pipeline-links.js");
+const pipeline_queue_js_1 = require("./routes/pipeline-queue.js");
+const run_log_service_1 = require("../logs/run-log-service");
+const pipeline_service_js_1 = require("../services/pipeline-service.js");
+const scheduler_service_js_1 = require("../services/scheduler-service.js");
+const data_dir_1 = require("../app/data-dir");
+const createApiHandler = (options) => {
+    const runLogService = (0, run_log_service_1.createRunLogService)({
+        rootDir: (0, data_dir_1.resolveTaskMeldDataPath)("logs", "runs"),
+    });
+    // Phase 1-5: 基于 Router 的路由迁移（全部路由模块）
+    const router = (0, router_js_1.createRouter)();
+    (0, health_js_1.registerHealthRoutes)(router);
+    (0, gateway_js_1.registerGatewayRoutes)(router);
+    (0, timeline_js_1.registerTimelineRoutes)(router);
+    (0, logs_js_1.registerLogRoutes)(router);
+    (0, artifacts_js_1.registerArtifactsRoutes)(router);
+    (0, agents_js_1.registerAgentsRoutes)(router);
+    (0, sessions_js_1.registerSessionsRoutes)(router);
+    (0, pipelines_js_1.registerPipelinesRoutes)(router);
+    (0, pipeline_workflow_js_1.registerPipelineWorkflowRoutes)(router);
+    (0, pipeline_runtime_js_1.registerPipelineRuntimeRoutes)(router);
+    (0, pipeline_batch_js_1.registerPipelineBatchRoutes)(router);
+    (0, pipeline_scheduler_js_1.registerPipelineSchedulerRoutes)(router);
+    (0, pipeline_diagnostics_js_1.registerPipelineDiagnosticsRoutes)(router);
+    (0, pipeline_outputs_js_1.registerPipelineOutputsRoutes)(router);
+    (0, pipeline_links_js_1.registerPipelineLinksRoutes)(router);
+    (0, pipeline_queue_js_1.registerPipelineQueueRoutes)(router);
+    const pipeline = (0, middleware_js_1.composeMiddleware)(middleware_js_1.errorMiddleware, (0, middleware_js_1.corsMiddleware)(options.webOrigin));
+    // 已迁移路由共享的 services
+    const pipelineService = (0, pipeline_service_js_1.createPipelineService)(options.app);
+    const schedulerService = (0, scheduler_service_js_1.createSchedulerService)(options.app);
+    const migratedServices = {
+        client: options.app.gateway.client,
+        getLatestStatus: options.app.gateway.getLatestStatus,
+        getLatestHello: options.app.gateway.getLatestHello,
+        getLastFrame: options.app.gateway.getLastFrame,
+        getTimeline: options.app.runtime.getCombinedTimeline,
+        runLogService,
+        pickArray: options.app.gateway.pickArray,
+        refreshSessionsFromGateway: options.app.gateway.refreshSessionsFromGateway,
+        getSessionCache: options.app.gateway.getSessionCache,
+        pushTimeline: (...args) => {
+            const primary = options.app.getPrimaryRuntime();
+            primary?.runtime.pushTimeline(...args);
+        },
+        listPipelines: options.app.listPipelines.bind(options.app),
+        getPipelineDefinition: options.app.getPipelineDefinition.bind(options.app),
+        pipelineService,
+        schedulerService,
+    };
+    return async (req, res) => {
+        const method = req.method ?? "GET";
+        const reqUrl = req.url ?? "/";
+        const url = new node_url_1.URL(reqUrl, `http://127.0.0.1:${options.apiPort}`);
+        // 全局 OPTIONS 处理：所有非 router 匹配的 OPTIONS 请求统一在此返回 204
+        // （router 匹配的 OPTIONS 由 corsMiddleware 在 pipeline 内处理）
+        if (method === "OPTIONS") {
+            res.writeHead(204, {
+                "Access-Control-Allow-Origin": options.webOrigin,
+                "Access-Control-Allow-Methods": "GET,POST,PATCH,DELETE,OPTIONS",
+                "Access-Control-Allow-Headers": "Content-Type",
+            });
+            res.end();
+            return;
+        }
+        const match = router.match(method, url.pathname);
+        if (match) {
+            let _bodyPromise = null;
+            const migratedCtx = {
+                req,
+                res,
+                method,
+                url,
+                params: match.params,
+                options,
+                services: migratedServices,
+                sendJson: (code, data) => (0, http_utils_1.sendJson)(res, code, data, options.webOrigin),
+                sendRaw: (code, headers, body) => {
+                    res.writeHead(code, {
+                        ...headers,
+                        "Access-Control-Allow-Origin": options.webOrigin,
+                        "Access-Control-Allow-Methods": "GET,POST,PATCH,DELETE,OPTIONS",
+                        "Access-Control-Allow-Headers": "Content-Type",
+                    });
+                    body.pipe(res);
+                },
+                readBody: () => {
+                    if (!_bodyPromise)
+                        _bodyPromise = (0, http_utils_1.readJsonBody)(req);
+                    return _bodyPromise;
+                },
+                getPipelineScope: () => {
+                    const pipelineId = match.params.pipelineId;
+                    if (!pipelineId)
+                        return null;
+                    const runtime = options.app.getPipelineRuntime(pipelineId);
+                    const definition = options.app.getPipelineDefinition(pipelineId);
+                    if (!runtime || !definition)
+                        return null;
+                    return {
+                        pipelineId: definition.id,
+                        workflowFilePath: definition.workflowFilePath,
+                        pushTimeline: runtime.runtime.pushTimeline,
+                        touchRun: runtime.runtime.touchRun,
+                        seedRun: runtime.runtime.seedRun,
+                        emitPipeline: runtime.runtime.emitPipeline,
+                        getRun: runtime.runtime.getRun,
+                        setRun: runtime.runtime.setRun,
+                        getTemplateNodes: runtime.workflow.getTemplateNodes,
+                        setTemplateNodes: runtime.workflow.setTemplateNodes,
+                        getWorkflow: runtime.workflow.getWorkflow,
+                        setWorkflow: runtime.workflow.setWorkflow,
+                        getItemRuns: runtime.pipeline.getItemRuns,
+                        drainPipeline: runtime.pipeline.drainPipeline,
+                        setSchedulerEnabled: runtime.pipeline.setSchedulerEnabled,
+                        setSchedulerMode: runtime.pipeline.setSchedulerMode,
+                        getSchedulerState: runtime.pipeline.getSchedulerState,
+                        getBatchRunState: runtime.pipeline.getBatchRunState,
+                        cancelBatchRun: runtime.pipeline.cancelBatchRun,
+                        executorSessionByAgentId: runtime.gateway.getExecutorSessionByAgentId(),
+                        getSessionCache: runtime.gateway.getSessionCache,
+                    };
+                },
+            };
+            await pipeline(migratedCtx, async () => {
+                await match.handler(migratedCtx);
+            });
+            return;
+        }
+        if (url.pathname.startsWith("/api/") || url.pathname === "/api") {
+            (0, http_utils_1.sendJson)(res, 404, { error: "not_found" }, options.webOrigin);
+            return;
+        }
+        // SPA static file serving — falls back to index.html for client-side routing
+        if ((0, serve_static_1.serveStatic)(req, res))
+            return;
+        (0, http_utils_1.sendJson)(res, 404, { error: "not_found" }, options.webOrigin);
+    };
+};
+exports.createApiHandler = createApiHandler;

package/dist/src/server/http-utils.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.firstText = exports.readJsonBody = exports.sendJson = void 0;
+const sendJson = (res, code, data, webOrigin) => {
+    res.writeHead(code, {
+        "Content-Type": "application/json; charset=utf-8",
+        "Access-Control-Allow-Origin": webOrigin,
+        "Access-Control-Allow-Methods": "GET,POST,PATCH,OPTIONS",
+        "Access-Control-Allow-Headers": "Content-Type",
+    });
+    res.end(JSON.stringify(data));
+};
+exports.sendJson = sendJson;
+const readJsonBody = async (req) => {
+    const chunks = [];
+    for await (const chunk of req) {
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    }
+    if (chunks.length === 0) {
+        return {};
+    }
+    return JSON.parse(Buffer.concat(chunks).toString("utf8"));
+};
+exports.readJsonBody = readJsonBody;
+const firstText = (body) => {
+    const candidates = [body.text, body.message, body.content, body.input];
+    for (const candidate of candidates) {
+        if (typeof candidate === "string" && candidate.trim()) {
+            return candidate.trim();
+        }
+    }
+    return "";
+};
+exports.firstText = firstText;

package/dist/src/server/middleware.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.corsMiddleware = exports.errorMiddleware = exports.composeMiddleware = void 0;
+const composeMiddleware = (...middlewares) => {
+    return (ctx, handler) => {
+        const execute = (index) => {
+            if (index >= middlewares.length) {
+                return Promise.resolve(handler(ctx)).then(() => { });
+            }
+            let nextCalled = false;
+            const next = () => {
+                if (nextCalled) {
+                    throw new Error("next() called multiple times in middleware");
+                }
+                nextCalled = true;
+                return execute(index + 1);
+            };
+            const result = middlewares[index](ctx, next);
+            return Promise.resolve(result).then(() => { });
+        };
+        return execute(0);
+    };
+};
+exports.composeMiddleware = composeMiddleware;
+const errorMiddleware = async (ctx, next) => {
+    try {
+        await next();
+    }
+    catch (_error) {
+        if (!ctx.res.headersSent) {
+            ctx.sendJson(500, { error: "internal_error" });
+        }
+        else {
+            try {
+                ctx.res.end();
+            }
+            catch {
+                // Socket may already be destroyed
+            }
+        }
+    }
+};
+exports.errorMiddleware = errorMiddleware;
+const corsMiddleware = (webOrigin) => {
+    return (ctx, next) => {
+        if (ctx.req.method === "OPTIONS") {
+            ctx.res.writeHead(204, {
+                "Access-Control-Allow-Origin": webOrigin,
+                "Access-Control-Allow-Methods": "GET,POST,PATCH,DELETE,OPTIONS",
+                "Access-Control-Allow-Headers": "Content-Type",
+            });
+            ctx.res.end();
+            return;
+        }
+        ctx.res.setHeader("Access-Control-Allow-Origin", webOrigin);
+        ctx.res.setHeader("Access-Control-Allow-Methods", "GET,POST,PATCH,DELETE,OPTIONS");
+        ctx.res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+        return next();
+    };
+};
+exports.corsMiddleware = corsMiddleware;

package/dist/src/server/router.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRouter = void 0;
+const createNode = () => ({
+    staticChildren: new Map(),
+    handlers: new Map(),
+});
+const createRouter = () => {
+    const root = createNode();
+    const register = (method, path, handler) => {
+        if (!path.startsWith("/")) {
+            throw new Error(`Route path must start with "/": ${path}`);
+        }
+        const normalizedMethod = method.toUpperCase();
+        const segments = path.split("/").slice(1);
+        let current = root;
+        for (let i = 0; i < segments.length; i++) {
+            const segment = segments[i];
+            if (!segment)
+                continue;
+            if (segment.startsWith("*")) {
+                const name = segment.slice(1);
+                if (!current.wildcardChild) {
+                    current.wildcardChild = { name, node: createNode() };
+                }
+                current = current.wildcardChild.node;
+            }
+            else if (segment.startsWith(":")) {
+                const name = segment.slice(1);
+                if (!current.paramChild) {
+                    current.paramChild = { name, node: createNode() };
+                }
+                current = current.paramChild.node;
+            }
+            else {
+                let child = current.staticChildren.get(segment);
+                if (!child) {
+                    child = createNode();
+                    current.staticChildren.set(segment, child);
+                }
+                current = child;
+            }
+        }
+        if (current.handlers.has(normalizedMethod)) {
+            throw new Error(`Duplicate route: ${normalizedMethod} ${path}`);
+        }
+        current.handlers.set(normalizedMethod, handler);
+    };
+    const match = (method, pathname) => {
+        const normalizedMethod = method.toUpperCase();
+        const segments = pathname.split("/").slice(1);
+        const params = {};
+        const matchNode = (node, index) => {
+            if (index >= segments.length) {
+                return node;
+            }
+            const segment = segments[index];
+            const staticChild = node.staticChildren.get(segment);
+            if (staticChild) {
+                const result = matchNode(staticChild, index + 1);
+                if (result)
+                    return result;
+            }
+            if (node.paramChild) {
+                try {
+                    const decoded = decodeURIComponent(segment);
+                    const prevParam = params[node.paramChild.name];
+                    params[node.paramChild.name] = decoded;
+                    const result = matchNode(node.paramChild.node, index + 1);
+                    if (result)
+                        return result;
+                    if (prevParam === undefined) {
+                        delete params[node.paramChild.name];
+                    }
+                    else {
+                        params[node.paramChild.name] = prevParam;
+                    }
+                }
+                catch {
+                    return null;
+                }
+            }
+            if (node.wildcardChild) {
+                const rest = segments.slice(index).join("/");
+                try {
+                    params[node.wildcardChild.name] = decodeURIComponent(rest);
+                }
+                catch {
+                    return null;
+                }
+                return node.wildcardChild.node;
+            }
+            return null;
+        };
+        const matchedNode = matchNode(root, 0);
+        if (!matchedNode)
+            return null;
+        const handler = matchedNode.handlers.get(normalizedMethod);
+        if (!handler)
+            return null;
+        return { handler, params };
+    };
+    return { register, match };
+};
+exports.createRouter = createRouter;

package/dist/src/server/routes/agents.js

@@ -0,0 +1,189 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerAgentsRoutes = void 0;
+const asRecord = (value) => value && typeof value === "object" && !Array.isArray(value)
+    ? value
+    : null;
+const toEpochMs = (value) => {
+    if (typeof value === "number" && Number.isFinite(value))
+        return value;
+    if (typeof value === "string" && value.trim()) {
+        const asNum = Number(value);
+        if (Number.isFinite(asNum))
+            return asNum;
+        const asDate = Date.parse(value);
+        if (Number.isFinite(asDate))
+            return asDate;
+    }
+    return null;
+};
+const readSessionActivityMs = (raw) => {
+    const candidates = [
+        raw.updatedAt,
+        raw.endedAt,
+        raw.startedAt,
+        raw.timestamp,
+        raw.ts,
+    ];
+    let best = null;
+    for (const candidate of candidates) {
+        const ms = toEpochMs(candidate);
+        if (ms === null)
+            continue;
+        if (best === null || ms > best)
+            best = ms;
+    }
+    return best;
+};
+const inferAgentIdsFromSession = (session) => {
+    const out = new Set();
+    const id = session.id.trim();
+    if (id) {
+        const match = id.match(/^agent:([^:]+):/i);
+        if (match?.[1])
+            out.add(match[1]);
+    }
+    const raw = session.raw;
+    const directKeys = [
+        raw.agentId,
+        raw.agent_id,
+        raw.executorAgentId,
+        raw.ownerAgentId,
+    ];
+    for (const value of directKeys) {
+        if (typeof value === "string" && value.trim())
+            out.add(value.trim());
+    }
+    return [...out];
+};
+const registerAgentsRoutes = (router) => {
+    router.register("GET", "/api/agents", async (ctx) => {
+        const services = ctx.services;
+        try {
+            const payload = await services.client.sendReq("agents.list");
+            const rawItems = services.pickArray(payload);
+            let sessionItems = services.getSessionCache();
+            try {
+                const refreshed = await services.refreshSessionsFromGateway();
+                sessionItems = refreshed.items;
+            }
+            catch {
+                // 即使 session 列表刷新临时失败，仍保持 /api/agents 可用
+            }
+            const lastActiveByAgentId = new Map();
+            for (const session of sessionItems) {
+                const activityMs = readSessionActivityMs(session.raw);
+                if (activityMs === null)
+                    continue;
+                const agentIds = inferAgentIdsFromSession(session);
+                for (const agentId of agentIds) {
+                    const prev = lastActiveByAgentId.get(agentId);
+                    if (prev === undefined || activityMs > prev) {
+                        lastActiveByAgentId.set(agentId, activityMs);
+                    }
+                }
+            }
+            const items = rawItems
+                .map((item) => {
+                const obj = asRecord(item);
+                if (!obj)
+                    return item;
+                const agentId = String(obj.id ?? obj.name ?? obj.key ?? "").trim();
+                const activeMs = agentId
+                    ? (lastActiveByAgentId.get(agentId) ?? null)
+                    : null;
+                return {
+                    ...obj,
+                    lastActiveAtMs: activeMs,
+                    lastActiveAt: activeMs ? new Date(activeMs).toISOString() : null,
+                };
+            })
+                .sort((a, b) => {
+                const aObj = asRecord(a);
+                const bObj = asRecord(b);
+                const aMs = toEpochMs(aObj?.lastActiveAtMs ?? aObj?.lastActiveAt) ?? -1;
+                const bMs = toEpochMs(bObj?.lastActiveAtMs ?? bObj?.lastActiveAt) ?? -1;
+                if (aMs !== bMs)
+                    return bMs - aMs;
+                const aId = String(aObj?.id ?? aObj?.name ?? "");
+                const bId = String(bObj?.id ?? bObj?.name ?? "");
+                return aId.localeCompare(bId);
+            });
+            ctx.sendJson(200, { items, raw: payload });
+        }
+        catch (error) {
+            ctx.sendJson(503, { error: String(error) });
+        }
+    });
+    router.register("GET", "/api/agents/:agentId/files", async (ctx) => {
+        const services = ctx.services;
+        try {
+            const agentId = ctx.params.agentId;
+            if (!agentId) {
+                ctx.sendJson(400, { error: "invalid_agent_id" });
+                return;
+            }
+            const payload = await services.client.sendReq("agents.files.list", {
+                agentId,
+            });
+            const obj = (payload ?? {});
+            const files = Array.isArray(obj.files)
+                ? obj.files
+                : services.pickArray(payload);
+            ctx.sendJson(200, { items: files, raw: payload });
+        }
+        catch (error) {
+            ctx.sendJson(503, { error: String(error) });
+        }
+    });
+    router.register("GET", "/api/agents/:agentId/files/*name", async (ctx) => {
+        const services = ctx.services;
+        try {
+            const agentId = ctx.params.agentId;
+            const name = ctx.params.name;
+            if (!agentId) {
+                ctx.sendJson(400, { error: "invalid_agent_id" });
+                return;
+            }
+            if (!name) {
+                ctx.sendJson(400, { error: "invalid_file_name" });
+                return;
+            }
+            const payload = await services.client.sendReq("agents.files.get", {
+                agentId,
+                name,
+            });
+            const obj = (payload ?? {});
+            const file = (obj.file ?? payload);
+            ctx.sendJson(200, { item: file ?? null, raw: payload });
+        }
+        catch (error) {
+            ctx.sendJson(503, { error: String(error) });
+        }
+    });
+    router.register("POST", "/api/agents/:agentId/files/*name", async (ctx) => {
+        const services = ctx.services;
+        try {
+            const agentId = ctx.params.agentId;
+            const name = ctx.params.name;
+            if (!agentId) {
+                ctx.sendJson(400, { error: "invalid_agent_id" });
+                return;
+            }
+            if (!name) {
+                ctx.sendJson(400, { error: "invalid_file_name" });
+                return;
+            }
+            const body = await ctx.readBody();
+            const content = typeof body.content === "string" ? body.content : "";
+            const payload = await services.client.sendReq("agents.files.set", { agentId, name, content }, { sideEffect: true });
+            const obj = (payload ?? {});
+            const file = (obj.file ?? payload);
+            ctx.sendJson(200, { item: file ?? null, raw: payload });
+        }
+        catch (error) {
+            ctx.sendJson(503, { error: String(error) });
+        }
+    });
+};
+exports.registerAgentsRoutes = registerAgentsRoutes;