taskmeld 0.1.2 → 0.1.41

package/dist/src/transport/ws-methods/artifacts.js

@@ -0,0 +1,171 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerArtifactWsMethods = 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 storage_service_2 = require("../../artifacts/storage-service");
+const parseCsvParam = (value) => {
+    if (typeof value !== "string")
+        return [];
+    return value.split(",").map((s) => s.trim()).filter(Boolean);
+};
+const registerArtifactWsMethods = (registry) => {
+    registry.register("artifact.list", async (params, ctx) => {
+        try {
+            const pipelineIds = parseCsvParam(params.pipelineId);
+            const nodeIds = parseCsvParam(params.nodeId);
+            const statuses = parseCsvParam(params.status);
+            const kinds = parseCsvParam(params.kind);
+            const dateFrom = typeof params.dateFrom === "string" && params.dateFrom.trim() ? params.dateFrom.trim() : null;
+            const dateTo = typeof params.dateTo === "string" && params.dateTo.trim() ? params.dateTo.trim() : null;
+            const cursor = typeof params.cursor === "string" && params.cursor.trim() ? params.cursor.trim() : undefined;
+            const batchRunId = typeof params.batchRunId === "string" && params.batchRunId.trim() ? params.batchRunId.trim() : undefined;
+            const runId = typeof params.runId === "string" && params.runId.trim() ? params.runId.trim() : undefined;
+            const limitRaw = typeof params.limit === "number" ? params.limit : 100;
+            const result = await (0, storage_service_1.listStoredArtifacts)(ctx.app.listPipelines(), {
+                pipelineIds,
+                nodeIds,
+                dateFrom,
+                dateTo,
+                limit: Number.isFinite(limitRaw) ? limitRaw : 100,
+                cursor,
+                statuses: statuses.length ? statuses : undefined,
+                kinds: kinds.length ? kinds : undefined,
+                batchRunId,
+                runId,
+            });
+            return {
+                ok: true,
+                payload: { items: result.items, nextCursor: result.nextCursor, source: result.source },
+            };
+        }
+        catch (error) {
+            return { ok: false, error: String(error) };
+        }
+    });
+    registry.register("artifact.content.get", async (params, ctx) => {
+        try {
+            const pipelineId = typeof params.pipelineId === "string" ? params.pipelineId.trim() : "";
+            const relativePath = typeof params.relativePath === "string" ? params.relativePath.trim() : "";
+            const artifactId = typeof params.artifactId === "string" ? params.artifactId.trim() : "";
+            if (!pipelineId || (!relativePath && !artifactId)) {
+                return { ok: false, error: "invalid_artifact_query" };
+            }
+            const definition = ctx.app.getPipelineDefinition(pipelineId);
+            if (!definition) {
+                return { ok: false, error: "pipeline_not_found" };
+            }
+            let resolvedPath = relativePath || undefined;
+            if (!resolvedPath && artifactId) {
+                const listResult = await (0, storage_service_1.listStoredArtifacts)(ctx.app.listPipelines(), {
+                    pipelineIds: [pipelineId],
+                    limit: 5000,
+                });
+                const match = listResult.items.find((item) => item.artifactId === artifactId);
+                resolvedPath = match?.relativePath ?? undefined;
+            }
+            if (!resolvedPath) {
+                return { ok: false, error: "artifact_not_found" };
+            }
+            const content = await (0, storage_service_1.readStoredArtifactContent)(definition, resolvedPath);
+            if (!content) {
+                return { ok: false, error: "artifact_not_found" };
+            }
+            return {
+                ok: true,
+                payload: { pipelineId, relativePath: resolvedPath, artifactId: artifactId || null, content },
+            };
+        }
+        catch (error) {
+            return { ok: false, error: String(error) };
+        }
+    });
+    registry.register("artifact.export", async (params, ctx) => {
+        try {
+            const pipelineIds = parseCsvParam(params.pipelineId);
+            const nodeIds = parseCsvParam(params.nodeId);
+            const dateFrom = typeof params.dateFrom === "string" && params.dateFrom.trim() ? params.dateFrom.trim() : null;
+            const dateTo = typeof params.dateTo === "string" && params.dateTo.trim() ? params.dateTo.trim() : null;
+            const limitRaw = typeof params.limit === "number" ? params.limit : 20000;
+            const kinds = parseCsvParam(params.kind);
+            const effectiveKinds = kinds.length > 0 ? kinds : ["artifact", "adapter", "group"];
+            const data = await (0, storage_service_1.exportStoredArtifactContents)(ctx.app.listPipelines(), {
+                pipelineIds,
+                nodeIds,
+                dateFrom,
+                dateTo,
+                limit: Number.isFinite(limitRaw) ? limitRaw : 20000,
+                kinds: effectiveKinds,
+            });
+            return { ok: true, payload: { data } };
+        }
+        catch (error) {
+            return { ok: false, error: String(error) };
+        }
+    });
+    registry.register("artifact.cleanup", async (params, ctx) => {
+        try {
+            const pipelineId = typeof params.pipelineId === "string" ? params.pipelineId.trim() : undefined;
+            const olderThanDaysRaw = typeof params.olderThanDays === "number" ? params.olderThanDays : 0;
+            const olderThanDays = olderThanDaysRaw || undefined;
+            const statusParam = typeof params.status === "string" ? params.status : "";
+            const statuses = statusParam ? statusParam.split(",").map((s) => s.trim()).filter(Boolean) : undefined;
+            const confirm = params.confirm === true;
+            const definitions = pipelineId
+                ? [ctx.app.getPipelineDefinition(pipelineId)].filter(Boolean)
+                : ctx.app.listPipelines();
+            if (definitions.length === 0) {
+                return { ok: false, error: "pipeline_not_found" };
+            }
+            let totalFiles = 0;
+            let totalSizeBytes = 0;
+            let deleted = 0;
+            let failed = 0;
+            const allWarnings = [];
+            for (const definition of definitions) {
+                const plan = await (0, artifact_cleanup_1.planCleanup)(definition, { olderThanDays, statuses });
+                totalFiles += plan.files.length;
+                totalSizeBytes += plan.totalSizeBytes;
+                if (confirm) {
+                    const execResult = await (0, artifact_cleanup_1.executeCleanup)(definition, plan);
+                    deleted += execResult.deleted;
+                    failed += execResult.failed;
+                    allWarnings.push(...execResult.warnings);
+                }
+            }
+            return {
+                ok: true,
+                payload: { totalFiles, totalSizeBytes, deleted, failed, dryRun: !confirm, warnings: allWarnings },
+            };
+        }
+        catch (error) {
+            return { ok: false, error: String(error) };
+        }
+    });
+    registry.register("artifact.rebuildIndex", async (params, ctx) => {
+        try {
+            const pipelineId = typeof params.pipelineId === "string" ? params.pipelineId.trim() : undefined;
+            const definitions = pipelineId
+                ? [ctx.app.getPipelineDefinition(pipelineId)].filter(Boolean)
+                : ctx.app.listPipelines();
+            if (definitions.length === 0) {
+                return { ok: false, error: "pipeline_not_found" };
+            }
+            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_2.scanStoredArtifacts)([d]));
+                indexed += result.indexed;
+                skipped += result.skipped;
+                warnings.push(...result.warnings);
+            }
+            return { ok: true, payload: { indexed, skipped, warnings } };
+        }
+        catch (error) {
+            return { ok: false, error: String(error) };
+        }
+    });
+};
+exports.registerArtifactWsMethods = registerArtifactWsMethods;

package/dist/src/transport/ws-methods/gateway.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerGatewayWsMethods = void 0;
+const registerGatewayWsMethods = (registry) => {
+    registry.register("gateway.status", (_params, ctx) => {
+        return {
+            ok: true,
+            payload: {
+                status: ctx.services.getLatestStatus?.() ?? ctx.services.client?.getStatus?.(),
+                hello: ctx.services.getLatestHello?.(),
+                lastFrame: ctx.services.getLastFrame?.(),
+            },
+        };
+    });
+};
+exports.registerGatewayWsMethods = registerGatewayWsMethods;

package/dist/src/transport/ws-methods/logs.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerLogWsMethods = void 0;
+const registerLogWsMethods = (registry) => {
+    registry.register("log.runs.list", async (_params, ctx) => {
+        try {
+            const items = ctx.services.runLogService ? await ctx.services.runLogService.listRuns() : [];
+            return { ok: true, payload: { items } };
+        }
+        catch (error) {
+            return { ok: false, error: String(error) };
+        }
+    });
+    registry.register("log.timeline", async (params, ctx) => {
+        const runId = typeof params.runId === "string" ? params.runId : "";
+        if (!runId || !ctx.services.runLogService) {
+            return { ok: false, error: runId ? "run_log_not_available" : "invalid_run_id" };
+        }
+        try {
+            const levelParam = typeof params.level === "string" ? params.level : "";
+            const levels = levelParam
+                ? (levelParam.split(",").map((s) => s.trim()).filter((s) => s === "info" || s === "warn" || s === "error"))
+                : undefined;
+            const offset = typeof params.offset === "number" && Number.isFinite(params.offset) ? params.offset : 0;
+            const limit = typeof params.limit === "number" && Number.isFinite(params.limit) ? params.limit : undefined;
+            const keyword = typeof params.keyword === "string" && params.keyword.trim() ? params.keyword.trim() : undefined;
+            const order = params.order === "asc" ? "asc" : "desc";
+            const page = await ctx.services.runLogService.queryTimeline({
+                runId,
+                offset,
+                limit,
+                keyword,
+                levels,
+                order,
+            });
+            return { ok: true, payload: page };
+        }
+        catch (error) {
+            return { ok: false, error: String(error) };
+        }
+    });
+};
+exports.registerLogWsMethods = registerLogWsMethods;

package/dist/src/transport/ws-methods/pipeline-batch.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerPipelineBatchWsMethods = void 0;
+const item_batch_controller_1 = require("../../pipeline/item-batch-controller");
+const pipeline_service_1 = require("../../services/pipeline-service");
+const utils_1 = require("./utils");
+const registerPipelineBatchWsMethods = (registry) => {
+    // pipeline.batchRun.status
+    registry.register("pipeline.batchRun.status", (params, ctx) => {
+        const pipelineId = typeof params.pipelineId === "string" ? params.pipelineId : "";
+        const runtime = ctx.app.getPipelineRuntime(pipelineId);
+        if (!runtime)
+            return { ok: false, error: "pipeline_not_found" };
+        const batchRunState = runtime.pipeline.getBatchRunState();
+        const identity = (0, pipeline_service_1.readPipelineIdentitySnapshot)(pipelineId, runtime.runtime.getRun(), batchRunState);
+        return { ok: true, payload: { ok: true, state: batchRunState, ...identity } };
+    });
+    // pipeline.batchRun.start
+    registry.register("pipeline.batchRun.start", async (params, ctx) => {
+        const pipelineId = typeof params.pipelineId === "string" ? params.pipelineId : "";
+        const runtime = ctx.app.getPipelineRuntime(pipelineId);
+        if (!runtime)
+            return { ok: false, error: "pipeline_not_found" };
+        const items = (0, item_batch_controller_1.normalizePoolItems)(params.items ?? params.keywords ?? params.pool ?? params);
+        const batchSize = typeof params.batchSize === "number" ? params.batchSize
+            : typeof params.size === "number" ? params.size
+                : typeof params.chunkSize === "number" ? params.chunkSize : undefined;
+        const startIndex = typeof params.startIndex === "number" ? params.startIndex : undefined;
+        const startBatch = typeof params.startBatch === "number" ? params.startBatch : undefined;
+        const started = ctx.services.pipelineService.startBatchRun({ pipelineId, items, batchSize, startIndex, startBatch });
+        if (started.ok === false) {
+            return { ok: false, error: started.error, payload: { ...started } };
+        }
+        return { ok: true, payload: { ok: true, state: started.state, pipelineId } };
+    });
+    // pipeline.batchRun.startRemote
+    registry.register("pipeline.batchRun.startRemote", async (params, ctx) => {
+        const pipelineId = typeof params.pipelineId === "string" ? params.pipelineId : "";
+        const runtime = ctx.app.getPipelineRuntime(pipelineId);
+        if (!runtime)
+            return { ok: false, error: "pipeline_not_found" };
+        const remoteUrl = typeof params.url === "string" ? params.url : undefined;
+        const batchSize = typeof params.batchSize === "number" ? params.batchSize
+            : typeof params.size === "number" ? params.size
+                : typeof params.chunkSize === "number" ? params.chunkSize : undefined;
+        const startIndex = typeof params.startIndex === "number" ? params.startIndex : undefined;
+        const startBatch = typeof params.startBatch === "number" ? params.startBatch : undefined;
+        const started = await ctx.services.pipelineService.startRemoteBatchRun({ pipelineId, url: remoteUrl, batchSize, startIndex, startBatch });
+        if (started.ok === false) {
+            return { ok: false, error: started.error, payload: { ...started } };
+        }
+        return { ok: true, payload: { ok: true, state: started.state, remoteUrl: started.remoteUrl, totalFetched: started.totalFetched, pipelineId } };
+    });
+    // pipeline.batchRun.stop
+    registry.register("pipeline.batchRun.stop", async (params, ctx) => {
+        const pipelineId = typeof params.pipelineId === "string" ? params.pipelineId : "";
+        const runtime = ctx.app.getPipelineRuntime(pipelineId);
+        if (!runtime)
+            return { ok: false, error: "pipeline_not_found" };
+        const target = (0, utils_1.mergeIdentityTargets)((0, utils_1.readIdentityTargetFromBody)(params), { runId: typeof params.runId === "string" ? params.runId : undefined, batchRunId: typeof params.batchRunId === "string" ? params.batchRunId : undefined });
+        const stopped = ctx.services.pipelineService.stopPipeline(pipelineId, target);
+        if (stopped.ok === false) {
+            return { ok: false, error: stopped.error, payload: { ...stopped } };
+        }
+        return { ok: true, payload: stopped };
+    });
+};
+exports.registerPipelineBatchWsMethods = registerPipelineBatchWsMethods;

package/dist/src/transport/ws-methods/pipeline-links.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerPipelineLinksWsMethods = void 0;
+const node_crypto_1 = require("node:crypto");
+const pipeline_link_1 = require("../../pipeline/types/pipeline-link");
+const registerPipelineLinksWsMethods = (registry) => {
+    // pipeline.link.list
+    registry.register("pipeline.link.list", async (_params, ctx) => {
+        const links = await ctx.app.dispatch.listLinks();
+        return { ok: true, payload: { ok: true, items: links } };
+    });
+    // pipeline.link.create
+    registry.register("pipeline.link.create", async (params, ctx) => {
+        const id = typeof params.id === "string" ? params.id.trim() : `link:${(0, node_crypto_1.randomUUID)()}`;
+        if (!(0, pipeline_link_1.isValidLinkId)(id)) {
+            return { ok: false, error: "pipeline_link_invalid_id" };
+        }
+        const fromPipelineId = typeof params.fromPipelineId === "string" ? params.fromPipelineId.trim() : "";
+        const toPipelineId = typeof params.toPipelineId === "string" ? params.toPipelineId.trim() : "";
+        if (!fromPipelineId || !toPipelineId) {
+            return { ok: false, error: "pipeline_link_missing_pipelines" };
+        }
+        if (!ctx.app.getPipelineDefinition(fromPipelineId)) {
+            return { ok: false, error: "pipeline_not_found" };
+        }
+        if (!ctx.app.getPipelineDefinition(toPipelineId)) {
+            return { ok: false, error: "pipeline_not_found" };
+        }
+        const contract = params.inputContract && typeof params.inputContract === "object"
+            ? {
+                requireType: typeof params.inputContract.requireType === "string"
+                    ? params.inputContract.requireType : undefined,
+                requireSchemaVersion: typeof params.inputContract.requireSchemaVersion === "number"
+                    ? params.inputContract.requireSchemaVersion : undefined,
+            } : null;
+        const maxPendingJobs = typeof params.maxPendingJobs === "number" && Number.isFinite(params.maxPendingJobs)
+            ? Math.min(10000, Math.max(1, Math.trunc(params.maxPendingJobs))) : 100;
+        const onJobFailed = params.onJobFailed === "pause" ? "pause" : "continue";
+        const now = new Date().toISOString();
+        const link = {
+            schemaVersion: 1,
+            id,
+            enabled: params.enabled !== false,
+            fromPipelineId,
+            toPipelineId,
+            trigger: "on_success",
+            dispatchPolicy: "fifo",
+            inputContract: contract,
+            onJobFailed,
+            maxPendingJobs,
+            createdAt: now,
+            updatedAt: now,
+        };
+        const result = await ctx.app.dispatch.createLink(link);
+        if (!result.ok) {
+            return { ok: false, error: result.error };
+        }
+        return { ok: true, payload: { ok: true, link: result.link } };
+    });
+    // pipeline.link.update
+    registry.register("pipeline.link.update", async (params, ctx) => {
+        const linkId = typeof params.linkId === "string" ? params.linkId : "";
+        if (!linkId)
+            return { ok: false, error: "pipeline_link_id_required" };
+        const patch = {};
+        if (typeof params.enabled === "boolean")
+            patch.enabled = params.enabled;
+        if (params.inputContract !== undefined) {
+            patch.inputContract = params.inputContract && typeof params.inputContract === "object"
+                ? {
+                    requireType: typeof params.inputContract.requireType === "string"
+                        ? params.inputContract.requireType : undefined,
+                    requireSchemaVersion: typeof params.inputContract.requireSchemaVersion === "number"
+                        ? params.inputContract.requireSchemaVersion : undefined,
+                } : null;
+        }
+        if (params.onJobFailed === "continue" || params.onJobFailed === "pause")
+            patch.onJobFailed = params.onJobFailed;
+        if (typeof params.maxPendingJobs === "number" && Number.isFinite(params.maxPendingJobs)) {
+            patch.maxPendingJobs = Math.min(10000, Math.max(1, Math.trunc(params.maxPendingJobs)));
+        }
+        const result = await ctx.app.dispatch.updateLink(linkId, patch);
+        if (!result.ok) {
+            return { ok: false, error: result.error };
+        }
+        return { ok: true, payload: { ok: true, link: result.link } };
+    });
+    // pipeline.link.delete
+    registry.register("pipeline.link.delete", async (params, ctx) => {
+        const linkId = typeof params.linkId === "string" ? params.linkId : "";
+        if (!linkId)
+            return { ok: false, error: "pipeline_link_id_required" };
+        const result = await ctx.app.dispatch.deleteLink(linkId);
+        if (!result.ok) {
+            return { ok: false, error: result.error };
+        }
+        return { ok: true, payload: { ok: true } };
+    });
+};
+exports.registerPipelineLinksWsMethods = registerPipelineLinksWsMethods;

package/dist/src/transport/ws-methods/pipeline-queue.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerPipelineQueueWsMethods = void 0;
+const registerPipelineQueueWsMethods = (registry) => {
+    // pipeline.queue.list
+    registry.register("pipeline.queue.list", (params, ctx) => {
+        const pipelineId = typeof params.pipelineId === "string" ? params.pipelineId : "";
+        if (!ctx.app.getPipelineDefinition(pipelineId)) {
+            return { ok: false, error: "pipeline_not_found" };
+        }
+        const items = ctx.app.dispatch.getQueue(pipelineId);
+        return { ok: true, payload: { ok: true, pipelineId, items } };
+    });
+    // pipeline.queue.retry
+    registry.register("pipeline.queue.retry", async (params, ctx) => {
+        const pipelineId = typeof params.pipelineId === "string" ? params.pipelineId : "";
+        const jobId = typeof params.jobId === "string" ? params.jobId : "";
+        if (!ctx.app.getPipelineDefinition(pipelineId)) {
+            return { ok: false, error: "pipeline_not_found" };
+        }
+        const result = await ctx.app.dispatch.retryJob(jobId);
+        if (!result.ok) {
+            return { ok: false, error: result.error };
+        }
+        return { ok: true, payload: { ok: true, job: result.job } };
+    });
+    // pipeline.queue.cancel
+    registry.register("pipeline.queue.cancel", async (params, ctx) => {
+        const pipelineId = typeof params.pipelineId === "string" ? params.pipelineId : "";
+        const jobId = typeof params.jobId === "string" ? params.jobId : "";
+        const reason = typeof params.reason === "string" && params.reason.trim() ? params.reason.trim() : "canceled_by_user";
+        if (!ctx.app.getPipelineDefinition(pipelineId)) {
+            return { ok: false, error: "pipeline_not_found" };
+        }
+        const result = await ctx.app.dispatch.cancelJob(jobId, reason);
+        if (!result.ok) {
+            return { ok: false, error: result.error };
+        }
+        return { ok: true, payload: { ok: true } };
+    });
+    // pipeline.queue.drain
+    registry.register("pipeline.queue.drain", (params, ctx) => {
+        const pipelineId = typeof params.pipelineId === "string" ? params.pipelineId : "";
+        if (!ctx.app.getPipelineDefinition(pipelineId)) {
+            return { ok: false, error: "pipeline_not_found" };
+        }
+        ctx.app.dispatch.drainQueue(pipelineId);
+        return { ok: true, payload: { ok: true, pipelineId } };
+    });
+};
+exports.registerPipelineQueueWsMethods = registerPipelineQueueWsMethods;

package/dist/src/transport/ws-methods/pipeline-runtime.js

@@ -0,0 +1,151 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerPipelineRuntimeWsMethods = void 0;
+const index_1 = require("../../pipeline/diagnostics/index");
+const utils_1 = require("./utils");
+const registerPipelineRuntimeWsMethods = (registry) => {
+    // pipeline.current
+    registry.register("pipeline.current", (params, ctx) => {
+        const pipelineId = typeof params.pipelineId === "string" ? params.pipelineId : "";
+        const runtime = ctx.app.getPipelineRuntime(pipelineId);
+        const definition = ctx.app.getPipelineDefinition(pipelineId);
+        if (!runtime || !definition) {
+            return { ok: false, error: "pipeline_not_found" };
+        }
+        const run = runtime.runtime.getRun();
+        const workflow = runtime.workflow.getWorkflow();
+        const nodes = workflow?.nodes && workflow.nodes.length > 0
+            ? run.nodes.map((node) => {
+                const matched = workflow.nodes.find((wNode) => wNode.id === node.id);
+                return { ...node, isMainline: matched?.isMainline ?? true, lane: matched?.lane ?? "main", parallelGroupId: matched?.parallelGroupId ?? null };
+            })
+            : run.nodes;
+        return {
+            ok: true,
+            payload: { run: { ...run, nodes }, runId: run.id, nodes, scheduler: runtime.pipeline.getSchedulerState(), pipelineId },
+        };
+    });
+    // pipeline.status
+    registry.register("pipeline.status", (params, ctx) => {
+        const pipelineId = typeof params.pipelineId === "string" ? params.pipelineId : "";
+        const runtime = ctx.app.getPipelineRuntime(pipelineId);
+        if (!runtime) {
+            return { ok: false, error: "pipeline_not_found" };
+        }
+        const target = (typeof params.runId === "string" || typeof params.batchRunId === "string")
+            ? { runId: typeof params.runId === "string" ? params.runId : undefined, batchRunId: typeof params.batchRunId === "string" ? params.batchRunId : undefined }
+            : undefined;
+        const result = ctx.services.pipelineService.getPipelineExecutionStatus(pipelineId, target);
+        return { ok: true, payload: result };
+    });
+    // pipeline.run
+    registry.register("pipeline.run", async (params, ctx) => {
+        const pipelineId = typeof params.pipelineId === "string" ? params.pipelineId : "";
+        const runtime = ctx.app.getPipelineRuntime(pipelineId);
+        if (!runtime) {
+            return { ok: false, error: "pipeline_not_found" };
+        }
+        const started = await ctx.services.pipelineService.startPipeline(pipelineId);
+        if (started.ok === false) {
+            return { ok: false, error: started.error, payload: { ...started } };
+        }
+        return { ok: true, payload: started };
+    });
+    // pipeline.stop
+    registry.register("pipeline.stop", async (params, ctx) => {
+        const pipelineId = typeof params.pipelineId === "string" ? params.pipelineId : "";
+        const runtime = ctx.app.getPipelineRuntime(pipelineId);
+        if (!runtime) {
+            return { ok: false, error: "pipeline_not_found" };
+        }
+        const target = (0, utils_1.mergeIdentityTargets)((0, utils_1.readIdentityTargetFromBody)(params), { runId: typeof params.runId === "string" ? params.runId : undefined, batchRunId: typeof params.batchRunId === "string" ? params.batchRunId : undefined });
+        const stopped = ctx.services.pipelineService.stopPipeline(pipelineId, target);
+        if (stopped.ok === false) {
+            return { ok: false, error: stopped.error, payload: { ...stopped } };
+        }
+        return { ok: true, payload: stopped };
+    });
+    // pipeline.executorBindings
+    registry.register("pipeline.executorBindings", (params, ctx) => {
+        const pipelineId = typeof params.pipelineId === "string" ? params.pipelineId : "";
+        const runtime = ctx.app.getPipelineRuntime(pipelineId);
+        if (!runtime) {
+            return { ok: false, error: "pipeline_not_found" };
+        }
+        const executorSessionByAgentId = runtime.gateway.getExecutorSessionByAgentId();
+        const sessionCache = runtime.gateway.getSessionCache();
+        return {
+            ok: true,
+            payload: {
+                bindings: Object.fromEntries(executorSessionByAgentId.entries()),
+                sessions: sessionCache.map((s) => ({ id: s.id, title: s.title })),
+                pipelineId,
+            },
+        };
+    });
+    // pipeline.node.retry
+    registry.register("pipeline.node.retry", async (params, ctx) => {
+        const pipelineId = typeof params.pipelineId === "string" ? params.pipelineId : "";
+        const nodeId = typeof params.nodeId === "string" ? params.nodeId : "";
+        const itemKey = typeof params.itemKey === "string" && params.itemKey.trim() ? params.itemKey.trim() : undefined;
+        const runtime = ctx.app.getPipelineRuntime(pipelineId);
+        if (!runtime) {
+            return { ok: false, error: "pipeline_not_found" };
+        }
+        if (!nodeId) {
+            return { ok: false, error: "node_id_required" };
+        }
+        const result = await ctx.services.pipelineService.retryNode({ pipelineId, nodeId, itemKey });
+        if (!result.ok) {
+            return { ok: false, error: result.error ?? "retry_failed", payload: result };
+        }
+        return { ok: true, payload: result };
+    });
+    // pipeline.node.diagnostics
+    registry.register("pipeline.node.diagnostics", (params, ctx) => {
+        const pipelineId = typeof params.pipelineId === "string" ? params.pipelineId : "";
+        const nodeId = typeof params.nodeId === "string" ? params.nodeId : "";
+        const itemKey = typeof params.itemKey === "string" && params.itemKey.trim() ? params.itemKey.trim() : undefined;
+        const runtime = ctx.app.getPipelineRuntime(pipelineId);
+        if (!runtime) {
+            return { ok: false, error: "pipeline_not_found" };
+        }
+        if (!nodeId) {
+            return { ok: false, error: "node_id_required" };
+        }
+        const workflowNode = runtime.workflow.getWorkflowNodeById(nodeId);
+        if (!workflowNode) {
+            return { ok: false, error: "node_not_found" };
+        }
+        const diagnostics = (0, index_1.diagnoseNodeDependency)(runtime.runtime.getRun(), runtime.workflow, nodeId, itemKey);
+        return { ok: true, payload: { nodeId, itemKey: itemKey ?? null, diagnostics } };
+    });
+    // pipeline.items
+    registry.register("pipeline.items", (params, ctx) => {
+        const pipelineId = typeof params.pipelineId === "string" ? params.pipelineId : "";
+        const runtime = ctx.app.getPipelineRuntime(pipelineId);
+        if (!runtime) {
+            return { ok: false, error: "pipeline_not_found" };
+        }
+        return { ok: true, payload: { items: runtime.pipeline.getItemRuns(), pipelineId } };
+    });
+    // pipeline.output.list
+    registry.register("pipeline.output.list", async (params, ctx) => {
+        const pipelineId = typeof params.pipelineId === "string" ? params.pipelineId : "";
+        const runtime = ctx.app.getPipelineRuntime(pipelineId);
+        if (!runtime) {
+            return { ok: false, error: "pipeline_not_found" };
+        }
+        const runId = typeof params.runId === "string" && params.runId.trim() ? params.runId.trim() : undefined;
+        const batchRunId = typeof params.batchRunId === "string" && params.batchRunId.trim() ? params.batchRunId.trim() : undefined;
+        const outputs = await runtime.output.list();
+        let filtered = outputs;
+        if (runId)
+            filtered = filtered.filter((o) => o.runId === runId);
+        if (batchRunId)
+            filtered = filtered.filter((o) => o.batchRunId === batchRunId);
+        filtered.sort((a, b) => b.producedAt.localeCompare(a.producedAt));
+        return { ok: true, payload: { ok: true, pipelineId, items: filtered } };
+    });
+};
+exports.registerPipelineRuntimeWsMethods = registerPipelineRuntimeWsMethods;

package/dist/src/transport/ws-methods/pipeline-scheduler.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerPipelineSchedulerWsMethods = void 0;
+const registerPipelineSchedulerWsMethods = (registry) => {
+    // pipeline.scheduler.toggle
+    registry.register("pipeline.scheduler.toggle", async (params, ctx) => {
+        const pipelineId = typeof params.pipelineId === "string" ? params.pipelineId : "";
+        const runtime = ctx.app.getPipelineRuntime(pipelineId);
+        if (!runtime)
+            return { ok: false, error: "pipeline_not_found" };
+        const enabled = params.enabled !== false;
+        const toggled = ctx.services.schedulerService.toggleScheduler(pipelineId, enabled);
+        if (!toggled.ok) {
+            return { ok: false, error: toggled.error };
+        }
+        runtime.runtime.pushTimeline(`[${pipelineId}] Scheduler ${toggled.scheduler.enabled ? "enabled" : "disabled"}`);
+        return { ok: true, payload: toggled };
+    });
+    // pipeline.scheduler.mode
+    registry.register("pipeline.scheduler.mode", async (params, ctx) => {
+        const pipelineId = typeof params.pipelineId === "string" ? params.pipelineId : "";
+        const runtime = ctx.app.getPipelineRuntime(pipelineId);
+        if (!runtime)
+            return { ok: false, error: "pipeline_not_found" };
+        const mode = params.mode === "manual" ? "manual" : "auto";
+        const updated = ctx.services.schedulerService.setSchedulerMode(pipelineId, mode);
+        if (!updated.ok) {
+            return { ok: false, error: updated.error };
+        }
+        runtime.runtime.pushTimeline(`[${pipelineId}] Scheduler mode switched to: ${updated.scheduler.mode}`);
+        return { ok: true, payload: updated };
+    });
+    // pipeline.tick
+    registry.register("pipeline.tick", async (params, ctx) => {
+        const pipelineId = typeof params.pipelineId === "string" ? params.pipelineId : "";
+        const runtime = ctx.app.getPipelineRuntime(pipelineId);
+        if (!runtime)
+            return { ok: false, error: "pipeline_not_found" };
+        const workflow = runtime.workflow.getWorkflow();
+        if (!workflow || !workflow.plugins.scheduler.enabled) {
+            return { ok: false, error: "pipeline_plugin_disabled" };
+        }
+        const drained = await runtime.pipeline.drainPipeline("manual_tick");
+        const run = runtime.runtime.getRun();
+        return { ok: true, payload: { ok: true, run, drained, pipelineId } };
+    });
+};
+exports.registerPipelineSchedulerWsMethods = registerPipelineSchedulerWsMethods;