taskmeld 0.1.1

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

@@ -0,0 +1,244 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerSessionsRoutes = void 0;
+const http_utils_js_1 = require("../http-utils.js");
+const asRecord = (value) => value && typeof value === "object" && !Array.isArray(value)
+    ? value
+    : null;
+const pickString = (record, keys) => {
+    for (const key of keys) {
+        const raw = record[key];
+        if (typeof raw === "string" && raw.trim())
+            return raw.trim();
+    }
+    return null;
+};
+const readModelInfo = (value) => {
+    const direct = asRecord(value);
+    if (!direct)
+        return { model: null, modelProvider: null, api: null };
+    const nestedSession = asRecord(direct.session);
+    const nestedMeta = asRecord(direct.meta);
+    const model = pickString(direct, ["model", "modelName"]) ??
+        (nestedSession
+            ? pickString(nestedSession, ["model", "modelName"])
+            : null) ??
+        (nestedMeta
+            ? pickString(nestedMeta, ["model", "modelName"])
+            : null);
+    const modelProvider = pickString(direct, ["modelProvider", "provider", "model_provider"]) ??
+        (nestedSession
+            ? pickString(nestedSession, [
+                "modelProvider",
+                "provider",
+                "model_provider",
+            ])
+            : null) ??
+        (nestedMeta
+            ? pickString(nestedMeta, ["modelProvider", "provider", "model_provider"])
+            : null);
+    const api = pickString(direct, ["api", "apiType"]) ??
+        (nestedSession
+            ? pickString(nestedSession, ["api", "apiType"])
+            : null) ??
+        (nestedMeta ? pickString(nestedMeta, ["api", "apiType"]) : null);
+    return { model, modelProvider, api };
+};
+const mergeModelInfo = (preferred, fallback) => ({
+    model: preferred.model ?? fallback.model,
+    modelProvider: preferred.modelProvider ?? fallback.modelProvider,
+    api: preferred.api ?? fallback.api,
+});
+const registerSessionsRoutes = (router) => {
+    router.register("GET", "/api/sessions", async (ctx) => {
+        const services = ctx.services;
+        try {
+            const { payload, items } = await services.refreshSessionsFromGateway();
+            ctx.sendJson(200, { items, raw: payload });
+        }
+        catch (error) {
+            ctx.sendJson(503, { error: String(error) });
+        }
+    });
+    router.register("GET", "/api/sessions/:sessionId/history", async (ctx) => {
+        const services = ctx.services;
+        try {
+            const sessionId = ctx.params.sessionId;
+            if (!sessionId) {
+                ctx.sendJson(400, { error: "invalid_session_id" });
+                return;
+            }
+            const limitRaw = Number(ctx.url.searchParams.get("limit") ?? 200);
+            const limit = Number.isFinite(limitRaw) && limitRaw > 0
+                ? Math.min(500, Math.floor(limitRaw))
+                : 200;
+            const payload = await services.client.sendReq("chat.history", {
+                sessionKey: sessionId,
+                limit,
+            });
+            const raw = (payload ?? {});
+            const rawItems = Array.isArray(raw.items)
+                ? raw.items
+                : Array.isArray(raw.messages)
+                    ? raw.messages
+                    : Array.isArray(raw.history)
+                        ? raw.history
+                        : Array.isArray(payload)
+                            ? payload
+                            : [];
+            const latestAssistant = [...rawItems]
+                .reverse()
+                .find((item) => String((asRecord(item) ?? {}).role ?? "").toLowerCase() === "assistant");
+            const latestModelInfo = readModelInfo(latestAssistant);
+            let sessionModelInfo = {
+                model: null,
+                modelProvider: null,
+                api: null,
+            };
+            try {
+                const { items } = await services.refreshSessionsFromGateway();
+                const matched = items.find((session) => session.id === sessionId);
+                sessionModelInfo = readModelInfo(matched?.raw);
+            }
+            catch {
+                // 即使 sessions.list 暂时不可用，仍保持 history 端点可用
+            }
+            const mergedInfo = mergeModelInfo(latestModelInfo, sessionModelInfo);
+            const items = rawItems.map((item) => {
+                const rec = asRecord(item);
+                if (!rec)
+                    return item;
+                const role = String(rec.role ?? "").toLowerCase();
+                if (role !== "assistant")
+                    return item;
+                const itemModelInfo = mergeModelInfo(readModelInfo(rec), mergedInfo);
+                return {
+                    ...rec,
+                    model: rec.model ?? itemModelInfo.model,
+                    modelProvider: rec.modelProvider ??
+                        rec.provider ??
+                        itemModelInfo.modelProvider,
+                    provider: rec.provider ??
+                        rec.modelProvider ??
+                        itemModelInfo.modelProvider,
+                    api: rec.api ?? itemModelInfo.api,
+                };
+            });
+            ctx.sendJson(200, {
+                items,
+                raw: payload,
+                limit,
+                model: mergedInfo.model,
+                modelProvider: mergedInfo.modelProvider,
+                api: mergedInfo.api,
+            });
+        }
+        catch (error) {
+            ctx.sendJson(503, { error: String(error) });
+        }
+    });
+    router.register("POST", "/api/sessions", async (ctx) => {
+        const services = ctx.services;
+        try {
+            const body = await ctx.readBody();
+            const payload = await services.client.sendReq("sessions.create", body, { sideEffect: true });
+            ctx.sendJson(200, { item: payload ?? null });
+        }
+        catch (error) {
+            ctx.sendJson(500, { error: String(error) });
+        }
+    });
+    router.register("POST", "/api/sessions/:sessionId/send", async (ctx) => {
+        const services = ctx.services;
+        try {
+            const sessionId = ctx.params.sessionId;
+            if (!sessionId) {
+                ctx.sendJson(400, { error: "invalid_session_id" });
+                return;
+            }
+            const body = await ctx.readBody();
+            const text = (0, http_utils_js_1.firstText)(body);
+            const mode = String(body.mode ?? "auto");
+            if (!text) {
+                ctx.sendJson(400, { error: "message_required" });
+                return;
+            }
+            const attempts = [];
+            const chatAttempts = [
+                {
+                    method: "chat.send",
+                    params: { sessionKey: sessionId, message: text },
+                },
+            ];
+            const sessionsAttempts = [
+                {
+                    method: "sessions.send",
+                    params: { key: sessionId, message: text },
+                },
+            ];
+            if (mode === "chat") {
+                attempts.push(...chatAttempts);
+            }
+            else if (mode === "sessions") {
+                attempts.push(...sessionsAttempts);
+            }
+            else {
+                attempts.push(...chatAttempts, ...sessionsAttempts);
+            }
+            let payload = null;
+            let lastError = null;
+            const attemptErrors = [];
+            let usedMethod = null;
+            let usedParams = null;
+            for (const attempt of attempts) {
+                try {
+                    payload = await services.client.sendReq(attempt.method, attempt.params, { sideEffect: true });
+                    usedMethod = attempt.method;
+                    usedParams = attempt.params;
+                    services.pushTimeline(`会话消息发送成功: ${sessionId} (${attempt.method})`);
+                    break;
+                }
+                catch (error) {
+                    lastError = error;
+                    attemptErrors.push(`${attempt.method}: ${String(error)}`);
+                }
+            }
+            if (payload === null) {
+                ctx.sendJson(500, {
+                    error: String(lastError ?? "sessions_send_failed"),
+                    attempts: attemptErrors,
+                    mode,
+                });
+                return;
+            }
+            let sessionModelInfo = {
+                model: null,
+                modelProvider: null,
+                api: null,
+            };
+            try {
+                const { items } = await services.refreshSessionsFromGateway();
+                const matched = items.find((session) => session.id === sessionId);
+                sessionModelInfo = readModelInfo(matched?.raw);
+            }
+            catch {
+                // 即使 sessions.list 刷新失败，仍保持 send 路径可用
+            }
+            const usedModelInfo = mergeModelInfo(readModelInfo(payload), sessionModelInfo);
+            ctx.sendJson(200, {
+                item: payload ?? null,
+                mode,
+                usedMethod,
+                usedParams,
+                model: usedModelInfo.model,
+                modelProvider: usedModelInfo.modelProvider,
+                api: usedModelInfo.api,
+            });
+        }
+        catch (error) {
+            services.pushTimeline(`会话消息发送失败: ${String(error)}`, "error");
+            ctx.sendJson(500, { error: String(error) });
+        }
+    });
+};
+exports.registerSessionsRoutes = registerSessionsRoutes;

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

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerTimelineRoutes = void 0;
+/**
+ * 注册 GET /api/timeline 路由。
+ * 返回合并后的全流水线时间线记录。
+ */
+const registerTimelineRoutes = (router) => {
+    router.register("GET", "/api/timeline", (ctx) => {
+        const services = ctx.services;
+        ctx.sendJson(200, { items: services.getTimeline() });
+    });
+};
+exports.registerTimelineRoutes = registerTimelineRoutes;

package/dist/src/server/serve-static.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serveStatic = void 0;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const MIME = {
+    ".html": "text/html; charset=utf-8",
+    ".css": "text/css; charset=utf-8",
+    ".js": "application/javascript; charset=utf-8",
+    ".json": "application/json; charset=utf-8",
+    ".svg": "image/svg+xml",
+    ".png": "image/png",
+    ".ico": "image/x-icon",
+    ".woff": "font/woff",
+    ".woff2": "font/woff2",
+};
+const resolveWebDist = () => {
+    // dist/src/server/serve-static.js → ../../../web/dist
+    return (0, node_path_1.join)(__dirname, "..", "..", "..", "web", "dist");
+};
+const webDistRoot = resolveWebDist();
+const serveStatic = (req, res) => {
+    if (!(0, node_fs_1.existsSync)(webDistRoot))
+        return false;
+    const url = new URL(req.url ?? "/", "http://localhost");
+    let filePath = (0, node_path_1.join)(webDistRoot, url.pathname === "/" ? "index.html" : url.pathname);
+    // If the path doesn't map to a real file, serve index.html (SPA fallback)
+    if (!(0, node_fs_1.existsSync)(filePath) || !filePath.startsWith(webDistRoot)) {
+        filePath = (0, node_path_1.join)(webDistRoot, "index.html");
+    }
+    if (!(0, node_fs_1.existsSync)(filePath))
+        return false;
+    const ext = (0, node_path_1.extname)(filePath);
+    const contentType = MIME[ext] ?? "application/octet-stream";
+    res.writeHead(200, {
+        "Content-Type": contentType,
+        "Cache-Control": ext === ".html" ? "no-cache" : "public, max-age=3600",
+    });
+    (0, node_fs_1.createReadStream)(filePath).pipe(res);
+    return true;
+};
+exports.serveStatic = serveStatic;

package/dist/src/server/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/services/agent-service.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAgentService = void 0;
+const gateway_read_helpers_1 = require("./gateway-read-helpers");
+const asRecord = (value) => value && typeof value === "object" ? value : 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 asNumber = typeof candidate === "number" && Number.isFinite(candidate) ? candidate : null;
+        const asDate = typeof candidate === "string" && candidate.trim() ? Date.parse(candidate) : Number.NaN;
+        const ms = asNumber ?? (Number.isFinite(asDate) ? asDate : null);
+        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 createAgentService = (app) => {
+    const listAgents = async () => {
+        await (0, gateway_read_helpers_1.ensureGatewayReadyForReadonly)(app);
+        const payload = await app.gateway.client.sendReq("agents.list");
+        const rawItems = app.gateway.pickArray(payload);
+        // 会话活动时间优先尝试刷新；刷新失败时回退缓存，保证只读查询可用性。
+        let sessionItems = app.gateway.getSessionCache();
+        try {
+            const refreshed = await app.gateway.refreshSessionsFromGateway();
+            sessionItems = refreshed.items;
+        }
+        catch {
+            // 只读查询容错：会话刷新失败不应阻断 agents.list 输出。
+        }
+        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);
+                }
+            }
+        }
+        return rawItems.map((item) => {
+            const obj = asRecord(item);
+            const agentId = obj ? String(obj.id ?? obj.name ?? obj.key ?? "").trim() || null : null;
+            const activeMs = agentId ? (lastActiveByAgentId.get(agentId) ?? null) : null;
+            return {
+                id: agentId,
+                raw: item,
+                lastActiveAtMs: activeMs,
+                lastActiveAt: activeMs ? new Date(activeMs).toISOString() : null,
+            };
+        });
+    };
+    return {
+        listAgents,
+    };
+};
+exports.createAgentService = createAgentService;

package/dist/src/services/artifact-service.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createArtifactService = void 0;
+const storage_service_1 = require("../artifacts/storage-service");
+const artifact_index_1 = require("../artifacts/artifact-index");
+const artifact_cleanup_1 = require("../artifacts/artifact-cleanup");
+const createArtifactService = (app) => {
+    const listArtifacts = async (query) => (0, storage_service_1.listStoredArtifacts)(app.listPipelines(), {
+        pipelineIds: query?.pipelineIds,
+        nodeIds: query?.nodeIds,
+        dateFrom: query?.dateFrom,
+        dateTo: query?.dateTo,
+        limit: query?.limit,
+        cursor: query?.cursor,
+        statuses: query?.statuses,
+        kinds: query?.kinds,
+        batchRunId: query?.batchRunId,
+        runId: query?.runId,
+    });
+    const getArtifactContent = async (query) => {
+        const definition = app.getPipelineDefinition(query.pipelineId);
+        if (!definition)
+            return null;
+        const content = await (0, storage_service_1.readStoredArtifactContent)(definition, query.relativePath);
+        if (!content)
+            return null;
+        return {
+            pipelineId: query.pipelineId,
+            relativePath: query.relativePath,
+            content,
+        };
+    };
+    const exportArtifactContents = async (query) => (0, storage_service_1.exportStoredArtifactContents)(app.listPipelines(), {
+        pipelineIds: query?.pipelineIds,
+        nodeIds: query?.nodeIds,
+        dateFrom: query?.dateFrom,
+        dateTo: query?.dateTo,
+        limit: query?.limit,
+    });
+    const rebuildIndexFn = async (pipelineId) => {
+        const definitions = pipelineId
+            ? [app.getPipelineDefinition(pipelineId)].filter(Boolean)
+            : app.listPipelines();
+        let indexed = 0;
+        let skipped = 0;
+        const warnings = [];
+        for (const definition of definitions) {
+            const result = await (0, artifact_index_1.rebuildArtifactIndex)(definition, (d) => (0, storage_service_1.scanStoredArtifacts)([d]));
+            indexed += result.indexed;
+            skipped += result.skipped;
+            warnings.push(...result.warnings);
+        }
+        return { indexed, skipped, warnings };
+    };
+    return {
+        listArtifacts,
+        getArtifactContent,
+        exportArtifactContents,
+        rebuildIndex: rebuildIndexFn,
+        planCleanup: (pipelineId, options) => {
+            const definition = app.getPipelineDefinition(pipelineId);
+            if (!definition)
+                throw new Error(`pipeline_not_found:${pipelineId}`);
+            return (0, artifact_cleanup_1.planCleanup)(definition, options);
+        },
+        executeCleanup: (pipelineId, plan) => {
+            const definition = app.getPipelineDefinition(pipelineId);
+            if (!definition)
+                throw new Error(`pipeline_not_found:${pipelineId}`);
+            return (0, artifact_cleanup_1.executeCleanup)(definition, plan);
+        },
+    };
+};
+exports.createArtifactService = createArtifactService;

package/dist/src/services/gateway-read-helpers.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureGatewayReadyForReadonly = void 0;
+const ensureGatewayReadyForReadonly = async (app) => {
+    if (app.gateway.client.getStatus().status === "ready")
+        return;
+    // 只读命令一旦命中网关方法，也必须先建好链路，否则 sendReq 会直接失败。
+    await app.gateway.client.connect();
+};
+exports.ensureGatewayReadyForReadonly = ensureGatewayReadyForReadonly;

package/dist/src/services/index.js

@@ -0,0 +1,23 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./system-service"), exports);
+__exportStar(require("./pipeline-service"), exports);
+__exportStar(require("./agent-service"), exports);
+__exportStar(require("./session-service"), exports);
+__exportStar(require("./artifact-service"), exports);
+__exportStar(require("./scheduler-service"), exports);
+__exportStar(require("./read-services"), exports);