@invect/mcp 0.0.1

package/dist/mcp-server-Brb4wc6I.mjs

@@ -0,0 +1,671 @@
+import { TOOL_IDS } from "./shared/types.mjs";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+//#region src/backend/auth.ts
+/**
+* Maps the MCP SDK's `authInfo` (from `ctx.http.authInfo`) to an InvectIdentity.
+* The authInfo is populated by the framework adapter's middleware which resolves
+* the session/API key before routing to the MCP plugin endpoint.
+*/
+function mapAuthInfoToIdentity(authInfo) {
+	if (!authInfo || typeof authInfo !== "object") return null;
+	const info = authInfo;
+	if (info.userId && typeof info.userId === "string") return authInfo;
+	return null;
+}
+/**
+* Extracts identity if available, returns null otherwise.
+* Used by tool handlers — the underlying client (HttpClient/DirectClient)
+* handles auth at its own layer, so a null identity is acceptable for
+* transports like stdio where auth is pre-established.
+*/
+function resolveIdentity(authInfo) {
+	return mapAuthInfoToIdentity(authInfo);
+}
+//#endregion
+//#region src/backend/response-mappers.ts
+/**
+* Response mappers — transform raw API responses into concise, LLM-friendly text.
+*
+* LLMs work better with:
+* - Flat, readable summaries instead of deeply nested JSON
+* - Relevant fields only (no internal IDs like flowVersion numbers unless useful)
+* - Human-readable dates and durations
+* - Markdown formatting for structure
+* - Truncated large payloads with clear indicators
+*/
+function formatDate(d) {
+	if (!d) return "N/A";
+	const date = typeof d === "string" ? new Date(d) : d instanceof Date ? d : null;
+	if (!date || isNaN(date.getTime())) return String(d);
+	return date.toISOString().replace("T", " ").replace(/\.\d+Z$/, " UTC");
+}
+function durationMs(start, end) {
+	if (!start || !end) return "N/A";
+	const s = new Date(start).getTime();
+	const ms = new Date(end).getTime() - s;
+	if (isNaN(ms)) return "N/A";
+	if (ms < 1e3) return `${ms}ms`;
+	if (ms < 6e4) return `${(ms / 1e3).toFixed(1)}s`;
+	return `${(ms / 6e4).toFixed(1)}m`;
+}
+function truncate(s, max = 200) {
+	if (s.length <= max) return s;
+	return s.slice(0, max) + "…";
+}
+function jsonCompact(obj, maxLen = 500) {
+	const s = JSON.stringify(obj);
+	if (s.length <= maxLen) return s;
+	return s.slice(0, maxLen) + `… (${s.length} chars total)`;
+}
+function mapFlowList(raw) {
+	const items = extractArray(raw);
+	if (items.length === 0) return "No flows found.";
+	const lines = items.map((f) => {
+		const tags = Array.isArray(f.tags) && f.tags.length > 0 ? ` [${f.tags.join(", ")}]` : "";
+		return `- **${f.name || "Untitled"}** (id: \`${f.id}\`)${tags}${f.description ? ` — ${truncate(String(f.description), 100)}` : ""}`;
+	});
+	return `**${items.length} flow(s):**\n\n${lines.join("\n")}`;
+}
+function mapFlow(raw) {
+	const f = raw;
+	if (!f || !f.id) return JSON.stringify(raw, null, 2);
+	return [
+		`**${f.name || "Untitled"}**`,
+		`- ID: \`${f.id}\``,
+		f.description ? `- Description: ${f.description}` : null,
+		f.status ? `- Status: ${f.status}` : null,
+		f.createdAt ? `- Created: ${formatDate(f.createdAt)}` : null,
+		f.updatedAt ? `- Updated: ${formatDate(f.updatedAt)}` : null
+	].filter(Boolean).join("\n");
+}
+function mapFlowDefinition(raw) {
+	const v = raw;
+	if (!v) return "No definition found.";
+	const def = v.invectDefinition ?? v.definition ?? v;
+	const nodes = Array.isArray(def.nodes) ? def.nodes : [];
+	const edges = Array.isArray(def.edges) ? def.edges : [];
+	const parts = [
+		v.version !== null && v.version !== void 0 ? `**Version ${v.version}**` : null,
+		v.flowId ? `Flow: \`${v.flowId}\`` : null,
+		`**${nodes.length} node(s), ${edges.length} edge(s)**`
+	];
+	if (nodes.length > 0) {
+		parts.push("", "## Nodes");
+		for (const n of nodes) {
+			const label = n.label || n.referenceId || n.id;
+			parts.push(`\n### \`${label}\``);
+			parts.push(`- **type:** ${n.type}`);
+			parts.push(`- **id:** \`${n.id}\``);
+			if (n.referenceId) parts.push(`- **referenceId:** \`${n.referenceId}\``);
+			const params = n.params;
+			if (params && Object.keys(params).length > 0) {
+				parts.push("- **params:**");
+				for (const [key, val] of Object.entries(params)) {
+					const valStr = typeof val === "string" ? val.includes("\n") ? `\n  \`\`\`\n  ${val.replace(/\n/g, "\n  ")}\n  \`\`\`` : val : JSON.stringify(val);
+					parts.push(`  - \`${key}\`: ${valStr}`);
+				}
+			}
+		}
+	}
+	if (edges.length > 0) {
+		parts.push("", "## Edges");
+		const nodeMap = new Map(nodes.map((n) => [n.id, n.label || n.referenceId || n.id]));
+		for (const e of edges) {
+			const from = nodeMap.get(e.source) || e.source;
+			const to = nodeMap.get(e.target) || e.target;
+			parts.push(`- ${from} → ${to}${e.sourceHandle ? ` (${e.sourceHandle})` : ""}`);
+		}
+	}
+	return parts.filter((p) => p !== null).join("\n");
+}
+function mapValidation(raw) {
+	const r = raw;
+	if (r.valid || r.isValid) return "Flow definition is **valid**.";
+	const errors = r.errors ?? [];
+	return `Flow definition is **invalid** (${errors.length} error(s)):\n${errors.map((e) => `- ${typeof e === "string" ? e : e.message || JSON.stringify(e)}`).join("\n")}`;
+}
+function mapVersionList(raw) {
+	const items = extractArray(raw);
+	if (items.length === 0) return "No versions found.";
+	return `**${items.length} version(s):**\n\n${items.map((v) => `- v${v.version}${v.createdAt ? ` (${formatDate(v.createdAt)})` : ""}${v.description ? ` — ${truncate(String(v.description), 80)}` : ""}`).join("\n")}`;
+}
+function mapRunList(raw) {
+	const items = extractArray(raw);
+	if (items.length === 0) return "No runs found.";
+	const lines = items.slice(0, 25).map((r) => {
+		const status = String(r.status || "UNKNOWN");
+		const icon = status === "SUCCESS" ? "✓" : status === "FAILED" ? "✗" : status === "RUNNING" ? "⏳" : "○";
+		const dur = durationMs(r.startedAt, r.completedAt);
+		const err = r.error ? ` — ${truncate(String(r.error), 60)}` : "";
+		return `- ${icon} \`${r.id}\` ${status} (${dur})${err}`;
+	});
+	const suffix = items.length > 25 ? `\n\n…and ${items.length - 25} more` : "";
+	return `**${items.length} run(s):**\n\n${lines.join("\n")}${suffix}`;
+}
+function mapRun(raw) {
+	const r = raw;
+	if (!r || !r.id) return JSON.stringify(raw, null, 2);
+	return [
+		`**Run \`${r.id}\`**`,
+		`- Status: **${r.status}**`,
+		`- Flow: \`${r.flowId}\``,
+		r.startedAt ? `- Started: ${formatDate(r.startedAt)}` : null,
+		r.completedAt ? `- Completed: ${formatDate(r.completedAt)} (${durationMs(r.startedAt, r.completedAt)})` : null,
+		r.error ? `- Error: ${truncate(String(r.error), 200)}` : null,
+		r.outputs ? `- Output: ${jsonCompact(r.outputs)}` : null
+	].filter(Boolean).join("\n");
+}
+function mapRunStarted(raw) {
+	const r = raw;
+	return `Flow run started: \`${r.flowRunId || r.id}\` (status: ${r.status || "RUNNING"})`;
+}
+function mapNodeExecutions(raw) {
+	const items = Array.isArray(raw) ? raw : [];
+	if (items.length === 0) return "No node executions found.";
+	const lines = items.map((n) => {
+		const status = String(n.status || "UNKNOWN");
+		const icon = status === "SUCCESS" ? "✓" : status === "FAILED" ? "✗" : "○";
+		const dur = durationMs(n.startedAt, n.completedAt);
+		const parts = [`### ${icon} \`${n.nodeId}\` (${n.nodeType}) — ${status} (${dur})`];
+		if (n.error) parts.push(`**Error:** ${String(n.error)}`);
+		if (n.inputs && Object.keys(n.inputs).length > 0) parts.push(`**Input:**\n\`\`\`json\n${JSON.stringify(n.inputs, null, 2)}\n\`\`\``);
+		if (n.outputs) parts.push(`**Output:**\n\`\`\`json\n${JSON.stringify(n.outputs, null, 2)}\n\`\`\``);
+		return parts.join("\n");
+	});
+	return `**${items.length} node execution(s):**\n\n${lines.join("\n\n")}`;
+}
+function mapTestResult(raw) {
+	const r = raw;
+	if (r.success === false || r.error) return `**Failed:** ${r.error || "Unknown error"}`;
+	return `**Result:** ${jsonCompact(r.output ?? r.result ?? r, 1e3)}`;
+}
+function mapCredentialList(raw) {
+	const items = Array.isArray(raw) ? raw : [];
+	if (items.length === 0) return "No credentials found.";
+	const lines = items.map((c) => `- **${c.name}** (id: \`${c.id}\`, type: ${c.type}${c.provider ? `, provider: ${c.provider}` : ""})`);
+	return `**${items.length} credential(s):**\n\n${lines.join("\n")}`;
+}
+function mapTriggerList(raw) {
+	const items = Array.isArray(raw) ? raw : [];
+	if (items.length === 0) return "No triggers found.";
+	const lines = items.map((t) => {
+		const type = t.type || t.triggerType || "unknown";
+		const enabled = t.enabled !== false ? "" : " (disabled)";
+		return `- **${t.name || type}** (id: \`${t.id}\`, type: ${type})${enabled}`;
+	});
+	return `**${items.length} trigger(s):**\n\n${lines.join("\n")}`;
+}
+function mapTrigger(raw) {
+	const t = raw;
+	if (!t || !t.id) return JSON.stringify(raw, null, 2);
+	return [
+		`**Trigger \`${t.id}\`**`,
+		`- Type: ${t.type || t.triggerType}`,
+		`- Flow: \`${t.flowId}\``,
+		t.enabled === false ? "- Status: **disabled**" : "- Status: enabled",
+		t.config ? `- Config: ${jsonCompact(t.config)}` : null
+	].filter(Boolean).join("\n");
+}
+function mapNodeList(raw) {
+	const items = Array.isArray(raw) ? raw : [];
+	if (items.length === 0) return "No nodes available.";
+	const grouped = /* @__PURE__ */ new Map();
+	for (const node of items) {
+		const p = node.provider;
+		const providerName = p ? String(p.name || p.id || "core") : "core";
+		if (!grouped.has(providerName)) grouped.set(providerName, []);
+		grouped.get(providerName)?.push(node);
+	}
+	const sections = [`**${items.length} node type(s) across ${grouped.size} provider(s):**`];
+	for (const [provider, nodes] of grouped) {
+		sections.push(`\n### ${provider} (${nodes.length})`);
+		for (const n of nodes) sections.push(`- \`${n.id}\` — ${n.name || n.id}${n.description ? `: ${truncate(String(n.description), 80)}` : ""}`);
+	}
+	return sections.join("\n");
+}
+function mapProviderList(raw) {
+	const items = Array.isArray(raw) ? raw : [];
+	if (items.length === 0) return "No providers found.";
+	const lines = items.map((p) => `- **${p.name || p.id}** (\`${p.id}\`)${p.description ? ` — ${truncate(String(p.description), 80)}` : ""}`);
+	return `**${items.length} provider(s):**\n\n${lines.join("\n")}`;
+}
+function extractArray(raw) {
+	if (Array.isArray(raw)) return raw;
+	if (raw && typeof raw === "object") {
+		const obj = raw;
+		if (Array.isArray(obj.data)) return obj.data;
+		if (Array.isArray(obj.items)) return obj.items;
+	}
+	return [];
+}
+//#endregion
+//#region src/backend/tools/flow-tools.ts
+/**
+* Flow management tools — CRUD operations on flows.
+*/
+function registerFlowTools(server, client) {
+	server.tool(TOOL_IDS.FLOW_LIST, "List all flows with their names, IDs, status, and metadata", {}, async (_params, extra) => {
+		const identity = resolveIdentity(extra.authInfo);
+		return { content: [{
+			type: "text",
+			text: mapFlowList(await client.listFlows(identity))
+		}] };
+	});
+	server.tool(TOOL_IDS.FLOW_GET, "Get detailed metadata for a specific flow by ID", { flowId: z.string().describe("The flow ID") }, async ({ flowId }, extra) => {
+		const identity = resolveIdentity(extra.authInfo);
+		return { content: [{
+			type: "text",
+			text: mapFlow(await client.getFlow(identity, flowId))
+		}] };
+	});
+	server.tool(TOOL_IDS.FLOW_GET_DEFINITION, "Get the current flow definition including all nodes, edges, and configuration parameters", { flowId: z.string().describe("The flow ID") }, async ({ flowId }, extra) => {
+		const identity = resolveIdentity(extra.authInfo);
+		return { content: [{
+			type: "text",
+			text: mapFlowDefinition(await client.getFlowDefinition(identity, flowId))
+		}] };
+	});
+	server.tool(TOOL_IDS.FLOW_CREATE, "Create a new empty flow with a name and optional description", {
+		name: z.string().describe("Flow name"),
+		description: z.string().optional().describe("Flow description")
+	}, async ({ name, description }, extra) => {
+		const identity = resolveIdentity(extra.authInfo);
+		return { content: [{
+			type: "text",
+			text: mapFlow(await client.createFlow(identity, {
+				name,
+				description
+			}))
+		}] };
+	});
+	server.tool(TOOL_IDS.FLOW_UPDATE, "Update a flow's name or description", {
+		flowId: z.string().describe("The flow ID"),
+		name: z.string().optional().describe("New name"),
+		description: z.string().optional().describe("New description")
+	}, async ({ flowId, name, description }, extra) => {
+		const identity = resolveIdentity(extra.authInfo);
+		return { content: [{
+			type: "text",
+			text: mapFlow(await client.updateFlow(identity, flowId, {
+				name,
+				description
+			}))
+		}] };
+	});
+	server.tool(TOOL_IDS.FLOW_DELETE, "Permanently delete a flow and all its versions and run history", { flowId: z.string().describe("The flow ID to delete") }, async ({ flowId }, extra) => {
+		const identity = resolveIdentity(extra.authInfo);
+		await client.deleteFlow(identity, flowId);
+		return { content: [{
+			type: "text",
+			text: `Flow ${flowId} deleted successfully.`
+		}] };
+	});
+	server.tool(TOOL_IDS.FLOW_VALIDATE, "Validate a flow definition against the schema without saving it", {
+		flowId: z.string().describe("The flow ID"),
+		definition: z.any().describe("The flow definition to validate")
+	}, async ({ flowId, definition }, extra) => {
+		const identity = resolveIdentity(extra.authInfo);
+		return { content: [{
+			type: "text",
+			text: mapValidation(await client.validateFlow(identity, flowId, definition))
+		}] };
+	});
+}
+//#endregion
+//#region src/backend/tools/version-tools.ts
+/**
+* Flow version management tools.
+*/
+function registerVersionTools(server, client) {
+	server.tool(TOOL_IDS.VERSION_LIST, "List all versions of a flow with version numbers and timestamps", { flowId: z.string().describe("The flow ID") }, async ({ flowId }, extra) => {
+		const identity = resolveIdentity(extra.authInfo);
+		return { content: [{
+			type: "text",
+			text: mapVersionList(await client.listVersions(identity, flowId))
+		}] };
+	});
+	server.tool(TOOL_IDS.VERSION_GET, "Get a specific version's full definition by version number or \"latest\"", {
+		flowId: z.string().describe("The flow ID"),
+		version: z.string().describe("Version number or \"latest\"")
+	}, async ({ flowId, version }, extra) => {
+		const identity = resolveIdentity(extra.authInfo);
+		return { content: [{
+			type: "text",
+			text: mapFlowDefinition(await client.getVersion(identity, flowId, version))
+		}] };
+	});
+	server.tool(TOOL_IDS.VERSION_PUBLISH, "Publish a new version of a flow with a complete definition (nodes, edges, configuration)", {
+		flowId: z.string().describe("The flow ID"),
+		definition: z.any().describe("The complete flow definition to publish")
+	}, async ({ flowId, definition }, extra) => {
+		const identity = resolveIdentity(extra.authInfo);
+		return { content: [{
+			type: "text",
+			text: mapFlowDefinition(await client.publishVersion(identity, flowId, definition))
+		}] };
+	});
+}
+//#endregion
+//#region src/backend/tools/run-tools.ts
+/**
+* Flow execution tools — start, monitor, and control flow runs.
+*/
+function registerRunTools(server, client) {
+	server.tool(TOOL_IDS.RUN_START, "Execute a flow synchronously with optional input values. Returns the full run result when complete.", {
+		flowId: z.string().describe("The flow ID to execute"),
+		inputs: z.record(z.unknown()).optional().describe("Optional key-value input data for the flow")
+	}, async ({ flowId, inputs }, extra) => {
+		const identity = resolveIdentity(extra.authInfo);
+		return { content: [{
+			type: "text",
+			text: mapRunStarted(await client.startRun(identity, flowId, inputs))
+		}] };
+	});
+	server.tool(TOOL_IDS.RUN_TO_NODE, "Execute a flow up to a specific node (for debugging). Returns partial results stopping at the target node.", {
+		flowId: z.string().describe("The flow ID"),
+		nodeId: z.string().describe("Stop execution at this node ID"),
+		inputs: z.record(z.unknown()).optional().describe("Optional input data")
+	}, async ({ flowId, nodeId, inputs }, extra) => {
+		const identity = resolveIdentity(extra.authInfo);
+		return { content: [{
+			type: "text",
+			text: mapRun(await client.runToNode(identity, flowId, nodeId, inputs))
+		}] };
+	});
+	server.tool(TOOL_IDS.RUN_LIST, "List execution history for a flow, including status, timing, and errors", { flowId: z.string().describe("The flow ID") }, async ({ flowId }, extra) => {
+		const identity = resolveIdentity(extra.authInfo);
+		return { content: [{
+			type: "text",
+			text: mapRunList(await client.listRuns(identity, flowId))
+		}] };
+	});
+	server.tool(TOOL_IDS.RUN_GET, "Get detailed results of a specific flow run including status, output, timing, and any errors", { flowRunId: z.string().describe("The flow run ID") }, async ({ flowRunId }, extra) => {
+		const identity = resolveIdentity(extra.authInfo);
+		return { content: [{
+			type: "text",
+			text: mapRun(await client.getRun(identity, flowRunId))
+		}] };
+	});
+	server.tool(TOOL_IDS.RUN_CANCEL, "Cancel a running flow execution", { flowRunId: z.string().describe("The flow run ID to cancel") }, async ({ flowRunId }, extra) => {
+		const identity = resolveIdentity(extra.authInfo);
+		return { content: [{
+			type: "text",
+			text: `Run ${flowRunId} cancelled. ${(await client.cancelRun(identity, flowRunId)).message || ""}`
+		}] };
+	});
+	server.tool(TOOL_IDS.RUN_PAUSE, "Pause a running flow execution (can be resumed later)", { flowRunId: z.string().describe("The flow run ID to pause") }, async ({ flowRunId }, extra) => {
+		const identity = resolveIdentity(extra.authInfo);
+		return { content: [{
+			type: "text",
+			text: `Run ${flowRunId} paused. ${(await client.pauseRun(identity, flowRunId)).message || ""}`
+		}] };
+	});
+	server.tool(TOOL_IDS.RUN_RESUME, "Resume a previously paused flow execution", { flowRunId: z.string().describe("The flow run ID to resume") }, async ({ flowRunId }, extra) => {
+		const identity = resolveIdentity(extra.authInfo);
+		return { content: [{
+			type: "text",
+			text: `Run ${flowRunId} resumed. ${(await client.resumeRun(identity, flowRunId)).message || ""}`
+		}] };
+	});
+}
+//#endregion
+//#region src/backend/tools/debug-tools.ts
+/**
+* Debugging & testing tools — node execution traces, expression testing, stats.
+*/
+function registerDebugTools(server, client) {
+	server.tool(TOOL_IDS.DEBUG_NODE_EXECUTIONS, "Get per-node execution traces for a flow run, including each node's input, output, timing, and errors. Essential for debugging failed runs.", { flowRunId: z.string().describe("The flow run ID") }, async ({ flowRunId }, extra) => {
+		const identity = resolveIdentity(extra.authInfo);
+		return { content: [{
+			type: "text",
+			text: mapNodeExecutions(await client.getNodeExecutions(identity, flowRunId))
+		}] };
+	});
+	server.tool(TOOL_IDS.DEBUG_TEST_NODE, "Execute a single node type in isolation with given parameters and input data. Useful for testing node configuration before adding to a flow.", {
+		nodeType: z.string().describe("Action ID of the node type (e.g., \"core.jq\", \"http.request\")"),
+		params: z.record(z.unknown()).describe("Node configuration parameters"),
+		inputData: z.record(z.unknown()).optional().describe("Simulated incoming data from upstream nodes")
+	}, async ({ nodeType, params, inputData }, extra) => {
+		const identity = resolveIdentity(extra.authInfo);
+		return { content: [{
+			type: "text",
+			text: mapTestResult(await client.testNode(identity, nodeType, params, inputData))
+		}] };
+	});
+	server.tool(TOOL_IDS.DEBUG_TEST_EXPRESSION, "Test a JavaScript template expression ({{ ... }}) against a sample data context. Uses the QuickJS WASM sandbox.", {
+		expression: z.string().describe("JS template expression to test (e.g., \"{{ users.filter(u => u.active).length }}\")"),
+		context: z.record(z.unknown()).describe("Sample data context to evaluate the expression against")
+	}, async ({ expression, context }, extra) => {
+		const identity = resolveIdentity(extra.authInfo);
+		return { content: [{
+			type: "text",
+			text: mapTestResult(await client.testJsExpression(identity, expression, context))
+		}] };
+	});
+	server.tool(TOOL_IDS.DEBUG_TEST_MAPPER, "Test a data mapper/transformation expression against sample incoming data", {
+		expression: z.string().describe("Mapper expression to evaluate"),
+		incomingData: z.record(z.unknown()).describe("Sample incoming data to map")
+	}, async ({ expression, incomingData }, extra) => {
+		const identity = resolveIdentity(extra.authInfo);
+		return { content: [{
+			type: "text",
+			text: mapTestResult(await client.testMapper(identity, expression, incomingData))
+		}] };
+	});
+}
+//#endregion
+//#region src/backend/tools/credential-tools.ts
+/**
+* Credential tools — reference-only (list metadata, test connectivity).
+* No create/delete/get-values for security.
+*/
+function registerCredentialTools(server, client) {
+	server.tool(TOOL_IDS.CREDENTIAL_LIST, "List all credentials with their names, types, and providers. Does NOT expose secrets — only metadata for referencing in flow configs.", {}, async (_params, extra) => {
+		const identity = resolveIdentity(extra.authInfo);
+		return { content: [{
+			type: "text",
+			text: mapCredentialList(await client.listCredentials(identity))
+		}] };
+	});
+	server.tool(TOOL_IDS.CREDENTIAL_TEST, "Test connectivity of a credential by ID. Verifies the credential is valid and can reach the external service.", { credentialId: z.string().describe("The credential ID to test") }, async ({ credentialId }, extra) => {
+		const identity = resolveIdentity(extra.authInfo);
+		return { content: [{
+			type: "text",
+			text: mapTestResult(await client.testCredential(identity, credentialId))
+		}] };
+	});
+}
+//#endregion
+//#region src/backend/tools/trigger-tools.ts
+/**
+* Trigger management tools — CRUD for flow triggers (cron, webhook, manual).
+*/
+function registerTriggerTools(server, client) {
+	server.tool(TOOL_IDS.TRIGGER_LIST, "List all triggers configured for a flow (cron schedules, webhooks, manual)", { flowId: z.string().describe("The flow ID") }, async ({ flowId }, extra) => {
+		const identity = resolveIdentity(extra.authInfo);
+		return { content: [{
+			type: "text",
+			text: mapTriggerList(await client.listTriggers(identity, flowId))
+		}] };
+	});
+	server.tool(TOOL_IDS.TRIGGER_GET, "Get details of a specific trigger", { triggerId: z.string().describe("The trigger ID") }, async ({ triggerId }, extra) => {
+		const identity = resolveIdentity(extra.authInfo);
+		return { content: [{
+			type: "text",
+			text: mapTrigger(await client.getTrigger(identity, triggerId))
+		}] };
+	});
+	server.tool(TOOL_IDS.TRIGGER_CREATE, "Create a new trigger for a flow (e.g., cron schedule, webhook)", { input: z.any().describe("Trigger creation input including flowId, type, and configuration") }, async ({ input }, extra) => {
+		const identity = resolveIdentity(extra.authInfo);
+		return { content: [{
+			type: "text",
+			text: mapTrigger(await client.createTrigger(identity, input))
+		}] };
+	});
+	server.tool(TOOL_IDS.TRIGGER_UPDATE, "Update an existing trigger's configuration", {
+		triggerId: z.string().describe("The trigger ID to update"),
+		input: z.any().describe("Updated trigger configuration")
+	}, async ({ triggerId, input }, extra) => {
+		const identity = resolveIdentity(extra.authInfo);
+		return { content: [{
+			type: "text",
+			text: mapTrigger(await client.updateTrigger(identity, triggerId, input))
+		}] };
+	});
+	server.tool(TOOL_IDS.TRIGGER_DELETE, "Delete a trigger", { triggerId: z.string().describe("The trigger ID to delete") }, async ({ triggerId }, extra) => {
+		const identity = resolveIdentity(extra.authInfo);
+		await client.deleteTrigger(identity, triggerId);
+		return { content: [{
+			type: "text",
+			text: `Trigger ${triggerId} deleted.`
+		}] };
+	});
+}
+//#endregion
+//#region src/backend/tools/node-tools.ts
+function registerNodeTools(server, client) {
+	server.tool(TOOL_IDS.NODE_LIST_PROVIDERS, "List all available node providers (core, http, gmail, slack, github, etc.) with their metadata", {}, async (_params, extra) => {
+		const identity = resolveIdentity(extra.authInfo);
+		return { content: [{
+			type: "text",
+			text: mapProviderList(await client.listProviders(identity))
+		}] };
+	});
+	server.tool(TOOL_IDS.NODE_LIST_AVAILABLE, "List all available node types with their IDs, names, parameter schemas, and field definitions. Use this to understand what nodes can be added to flows.", {}, async (_params, extra) => {
+		const identity = resolveIdentity(extra.authInfo);
+		return { content: [{
+			type: "text",
+			text: mapNodeList(await client.listAvailableNodes(identity))
+		}] };
+	});
+}
+//#endregion
+//#region src/backend/resources/index.ts
+function registerResources(server, client) {
+	server.resource("flow-definition", "invect://flows/{flowId}/definition", { description: "The current definition of a specific flow (nodes, edges, params)" }, async (uri, extra) => {
+		const identity = resolveIdentity(extra.authInfo);
+		const match = uri.href.match(/^invect:\/\/flows\/([^/]+)\/definition$/);
+		if (!match?.[1]) return { contents: [{
+			uri: uri.href,
+			text: "Invalid flow URI",
+			mimeType: "text/plain"
+		}] };
+		const flowId = decodeURIComponent(match[1]);
+		const def = await client.getFlowDefinition(identity, flowId);
+		return { contents: [{
+			uri: uri.href,
+			text: JSON.stringify(def, null, 2),
+			mimeType: "application/json"
+		}] };
+	});
+	server.resource("flow-run", "invect://runs/{flowRunId}", { description: "The result details of a specific flow run" }, async (uri, extra) => {
+		const identity = resolveIdentity(extra.authInfo);
+		const match = uri.href.match(/^invect:\/\/runs\/([^/]+)$/);
+		if (!match?.[1]) return { contents: [{
+			uri: uri.href,
+			text: "Invalid run URI",
+			mimeType: "text/plain"
+		}] };
+		const flowRunId = decodeURIComponent(match[1]);
+		const run = await client.getRun(identity, flowRunId);
+		return { contents: [{
+			uri: uri.href,
+			text: JSON.stringify(run, null, 2),
+			mimeType: "application/json"
+		}] };
+	});
+}
+//#endregion
+//#region src/backend/prompts/index.ts
+/**
+* MCP Prompts — reusable prompt templates for common Invect tasks.
+*/
+function registerPrompts(server, _client) {
+	server.prompt("debug-flow-run", "Analyze a failed or problematic flow run to identify the root cause", { flowRunId: z.string().describe("The flow run ID to debug") }, async ({ flowRunId }) => {
+		return { messages: [{
+			role: "user",
+			content: {
+				type: "text",
+				text: [
+					`Debug the flow run "${flowRunId}". Follow these steps:`,
+					"",
+					"1. Use run_get to fetch the run details (status, error, timing).",
+					"2. Use debug_node_executions to get per-node traces.",
+					"3. Identify which node(s) failed or produced unexpected output.",
+					"4. If a node has an expression error, use debug_test_expression with the failed expression and the node's input data.",
+					"5. Summarize: root cause, which node failed, and suggest a fix."
+				].join("\n")
+			}
+		}] };
+	});
+	server.prompt("create-flow", "Step-by-step guide to create a new flow with nodes and connections", {
+		name: z.string().describe("Name for the new flow"),
+		description: z.string().optional().describe("What the flow should do")
+	}, async ({ name, description }) => {
+		return { messages: [{
+			role: "user",
+			content: {
+				type: "text",
+				text: [
+					`Create a new Invect flow called "${name}"${description ? `: ${description}` : ""}.`,
+					"",
+					"Follow these steps:",
+					"1. Use node_list_available to see all available node types.",
+					"2. Use flow_create to create the flow.",
+					"3. Plan the node graph: decide which nodes are needed, their parameters, and how they connect.",
+					"4. Use version_publish to publish the flow definition with nodes and edges.",
+					"5. Use flow_validate to verify the definition is correct.",
+					"6. Optionally use run_start to test the flow."
+				].join("\n")
+			}
+		}] };
+	});
+	server.prompt("explain-flow", "Get a detailed explanation of what a flow does, its nodes, and data flow", { flowId: z.string().describe("The flow ID to explain") }, async ({ flowId }) => {
+		return { messages: [{
+			role: "user",
+			content: {
+				type: "text",
+				text: [
+					`Explain the flow "${flowId}" in detail.`,
+					"",
+					"1. Use flow_get to get the flow metadata.",
+					"2. Use flow_get_definition to get the full definition.",
+					"3. Analyze the nodes, their types, parameters, and connections (edges).",
+					"4. Describe the data flow from inputs through each node to outputs.",
+					"5. Flag any potential issues or improvements."
+				].join("\n")
+			}
+		}] };
+	});
+}
+//#endregion
+//#region src/backend/mcp-server.ts
+/**
+* MCP Server factory — creates and configures the McpServer with all tools,
+* resources, and prompts.
+*/
+function createMcpServer(client) {
+	const server = new McpServer({
+		name: "invect-mcp",
+		version: "0.0.1"
+	}, { capabilities: {
+		tools: {},
+		resources: {},
+		prompts: {}
+	} });
+	registerFlowTools(server, client);
+	registerVersionTools(server, client);
+	registerRunTools(server, client);
+	registerDebugTools(server, client);
+	registerCredentialTools(server, client);
+	registerTriggerTools(server, client);
+	registerNodeTools(server, client);
+	registerResources(server, client);
+	registerPrompts(server, client);
+	return server;
+}
+//#endregion
+export { createMcpServer as t };
+
+//# sourceMappingURL=mcp-server-Brb4wc6I.mjs.map