@alfe.ai/connectwise-screenconnect-mcp 0.1.0

package/dist/server.d.ts

@@ -0,0 +1,24 @@
+import { r as ScreenConnectApi } from "./screenconnect-client.js";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+
+//#region src/tools.d.ts
+interface ConnectApi {
+  getConnectProviderAccounts(provider: string): Promise<unknown>;
+  getConnectionCredentials(connectionId: string): Promise<unknown>;
+}
+interface ToolDependencies {
+  createClient?: (credentials: {
+    siteUrl: string;
+    authenticationSecret: string;
+  }) => ScreenConnectApi;
+  /** Receives only a static sanitized error and operation name, never credentials or provider bodies. */
+  captureError?: (error: Error, operation: string) => void;
+}
+//#endregion
+//#region src/server.d.ts
+declare const SERVER_VERSION: string;
+declare const SERVER_NAME = "connectwise-screenconnect-mcp";
+declare function createServer(api: ConnectApi, dependencies?: ToolDependencies): McpServer;
+declare function startServer(api?: ConnectApi, dependencies?: ToolDependencies): Promise<McpServer>;
+//#endregion
+export { type ConnectApi, SERVER_NAME, SERVER_VERSION, type ToolDependencies, createServer, startServer };

package/dist/server.js

@@ -0,0 +1,2 @@
+import { i as startServer, n as SERVER_VERSION, r as createServer, t as SERVER_NAME } from "./server2.js";
+export { SERVER_NAME, SERVER_VERSION, createServer, startServer };

package/dist/server2.cjs

@@ -0,0 +1,286 @@
+const require_screenconnect_client = require("./screenconnect-client2.cjs");
+let zod = require("zod");
+let node_module = require("node:module");
+let _alfe_ai_agent_api_client = require("@alfe.ai/agent-api-client");
+let _alfe_ai_config = require("@alfe.ai/config");
+let _modelcontextprotocol_sdk_server_mcp_js = require("@modelcontextprotocol/sdk/server/mcp.js");
+let _modelcontextprotocol_sdk_server_stdio_js = require("@modelcontextprotocol/sdk/server/stdio.js");
+//#region src/tools.ts
+const readAnnotations = {
+	readOnlyHint: true,
+	destructiveHint: false,
+	idempotentHint: true,
+	openWorldHint: true
+};
+const addAnnotations = {
+	readOnlyHint: false,
+	destructiveHint: false,
+	idempotentHint: false,
+	openWorldHint: true
+};
+const updateAnnotations = {
+	readOnlyHint: false,
+	destructiveHint: true,
+	idempotentHint: true,
+	openWorldHint: true
+};
+const actionAnnotations = {
+	readOnlyHint: false,
+	destructiveHint: true,
+	idempotentHint: false,
+	openWorldHint: true
+};
+const selected = { connectionId: require_screenconnect_client.connectionIdField };
+const session = {
+	...selected,
+	sessionId: require_screenconnect_client.sessionIdField
+};
+const limitField = zod.z.coerce.number().int().min(1).max(500).default(100);
+function registerTools(server, api, dependencies = {}) {
+	const createClient = dependencies.createClient ?? ((credentials) => new require_screenconnect_client.ScreenConnectClient(credentials));
+	const client = async (connectionId) => {
+		return createClient(require_screenconnect_client.parseCredentials(await api.getConnectionCredentials(connectionId), connectionId));
+	};
+	const guarded = async (operation, work) => {
+		try {
+			return { content: [{
+				type: "text",
+				text: JSON.stringify(await work())
+			}] };
+		} catch (error) {
+			const message = require_screenconnect_client.safeErrorMessage(error);
+			try {
+				dependencies.captureError?.(new Error(message), operation);
+			} catch {}
+			return {
+				isError: true,
+				content: [{
+					type: "text",
+					text: message
+				}]
+			};
+		}
+	};
+	server.registerTool("screenconnect_list_connections", {
+		description: "List authorized ScreenConnect connections and their exact connectionId selectors. Does not expose authentication secrets.",
+		inputSchema: {},
+		annotations: readAnnotations
+	}, () => guarded("list_connections", async () => {
+		const raw = await api.getConnectProviderAccounts(require_screenconnect_client.PROVIDER);
+		if (!require_screenconnect_client.isRecord(raw) || raw.provider !== "connectwise-screenconnect" || !Array.isArray(raw.accounts) || raw.accounts.length > 500) throw new require_screenconnect_client.ScreenConnectError("Invalid ScreenConnect connection list returned by Alfe.");
+		return { connections: raw.accounts.map((account) => {
+			const row = zod.z.object({
+				connectionId: require_screenconnect_client.connectionIdField,
+				accountIdentifier: zod.z.string().max(2048),
+				displayName: zod.z.string().max(512).nullable().optional(),
+				siteUrl: zod.z.string()
+			}).safeParse(account);
+			if (!row.success) throw new require_screenconnect_client.ScreenConnectError("Invalid ScreenConnect connection metadata returned by Alfe.");
+			return {
+				...row.data,
+				siteUrl: require_screenconnect_client.normalizeSiteUrl(row.data.siteUrl)
+			};
+		}) };
+	}));
+	server.registerTool("screenconnect_check_connection", {
+		description: "Verify authentication and the RESTful API Manager extension with an empty session filter. Does not change sessions.",
+		inputSchema: selected,
+		annotations: readAnnotations
+	}, (args) => guarded("check_connection", async () => {
+		boundedSessions(await (await client(args.connectionId)).call("GetSessionsByFilter", ["SessionID = '00000000-0000-0000-0000-000000000000'"]), 1);
+		return { connected: true };
+	}));
+	server.registerTool("screenconnect_list_sessions", {
+		description: "Find sessions with a required ScreenConnect session filter (for example SessionType = 'Access'). Limit bounds returned items only; the extension has no pagination. Narrow filters for large instances.",
+		inputSchema: {
+			...selected,
+			filter: require_screenconnect_client.textField(2048),
+			limit: limitField
+		},
+		annotations: readAnnotations
+	}, (args) => guarded("list_sessions", async () => boundedSessions(await (await client(args.connectionId)).call("GetSessionsByFilter", [args.filter]), args.limit)));
+	server.registerTool("screenconnect_find_sessions", {
+		description: "Look up sessions by name. Limit bounds returned items; the extension does not expose pagination.",
+		inputSchema: {
+			...selected,
+			name: require_screenconnect_client.textField(256),
+			limit: limitField
+		},
+		annotations: readAnnotations
+	}, (args) => guarded("find_sessions", async () => boundedSessions(await (await client(args.connectionId)).call("GetSessionsByName", [args.name]), args.limit)));
+	server.registerTool("screenconnect_get_session", {
+		description: "Get session data by its ScreenConnect session GUID.",
+		inputSchema: session,
+		annotations: readAnnotations
+	}, (args) => guarded("get_session", async () => (await client(args.connectionId)).call("GetSessionBySessionID", [args.sessionId])));
+	server.registerTool("screenconnect_get_session_details", {
+		description: "Get session details including events and connection history. Screenshot bytes are omitted.",
+		inputSchema: session,
+		annotations: readAnnotations
+	}, (args) => guarded("get_session_details", async () => {
+		const details = await (await client(args.connectionId)).call("GetSessionDetailsBySessionID", [args.sessionId]);
+		if (details === null) return null;
+		if (!require_screenconnect_client.isRecord(details)) throw new require_screenconnect_client.ScreenConnectError("ScreenConnect returned malformed session details.");
+		return Object.fromEntries(Object.entries(details).filter(([key]) => key !== "GuestScreenshotContent"));
+	}));
+	server.registerTool("screenconnect_create_session", {
+		description: "Create a Support or Meeting session. Access agents/installers are a separate ScreenConnect flow. Private sessions require a join code.",
+		inputSchema: {
+			...selected,
+			sessionType: zod.z.enum(["Support", "Meeting"]),
+			name: require_screenconnect_client.textField(256),
+			isPublic: zod.z.boolean().default(false),
+			code: zod.z.string().max(128).default(""),
+			customProperties: require_screenconnect_client.customPropertiesField.default([])
+		},
+		annotations: addAnnotations
+	}, (args) => guarded("create_session", async () => {
+		if (!args.isPublic && !args.code.trim()) throw new require_screenconnect_client.ScreenConnectError("Private ScreenConnect sessions require a join code.");
+		return (await client(args.connectionId)).call("CreateSession", [
+			args.sessionType,
+			args.name,
+			args.isPublic,
+			args.code,
+			args.customProperties
+		]);
+	}));
+	server.registerTool("screenconnect_rename_session", {
+		description: "Replace the display name of one ScreenConnect session.",
+		inputSchema: {
+			...session,
+			name: require_screenconnect_client.textField(256)
+		},
+		annotations: updateAnnotations
+	}, (args) => guarded("rename_session", async () => {
+		await (await client(args.connectionId)).call("UpdateSessionName", [args.sessionId, args.name]);
+		return { updated: true };
+	}));
+	server.registerTool("screenconnect_update_custom_properties", {
+		description: "Replace all custom property values in positional order (up to eight). Read the session first and retain any values that should remain.",
+		inputSchema: {
+			...session,
+			customProperties: require_screenconnect_client.customPropertiesField
+		},
+		annotations: updateAnnotations
+	}, (args) => guarded("update_custom_properties", async () => {
+		await (await client(args.connectionId)).call("UpdateSessionCustomProperties", [args.sessionId, args.customProperties]);
+		return { updated: true };
+	}));
+	server.registerTool("screenconnect_add_note", {
+		description: "Append a note to one ScreenConnect session (RESTful API Manager 1.0.6 or newer).",
+		inputSchema: {
+			...session,
+			note: require_screenconnect_client.textField(16384)
+		},
+		annotations: addAnnotations
+	}, (args) => guarded("add_note", async () => {
+		await (await client(args.connectionId)).call("AddNoteToSession", [args.sessionId, args.note]);
+		return { accepted: true };
+	}));
+	server.registerTool("screenconnect_send_message", {
+		description: "Send a chat message to one session, attributed to the specified host name.",
+		inputSchema: {
+			...session,
+			byHost: require_screenconnect_client.textField(256),
+			message: require_screenconnect_client.textField(16384)
+		},
+		annotations: addAnnotations
+	}, (args) => guarded("send_message", async () => {
+		await (await client(args.connectionId)).call("SendMessageToSession", [
+			args.sessionId,
+			args.byHost,
+			args.message
+		]);
+		return { accepted: true };
+	}));
+	server.registerTool("screenconnect_run_command", {
+		description: "Queue a command on the selected remote session. Confirm the exact session and command. Acceptance does not prove execution; inspect session details for results before retrying.",
+		inputSchema: {
+			...session,
+			command: require_screenconnect_client.textField(32768),
+			confirmSessionId: require_screenconnect_client.sessionIdField,
+			confirmCommand: require_screenconnect_client.textField(32768)
+		},
+		annotations: actionAnnotations
+	}, (args) => guarded("run_command", async () => {
+		if (args.confirmSessionId !== args.sessionId || args.confirmCommand !== args.command) throw new require_screenconnect_client.ScreenConnectError("Confirm the exact sessionId and command before running a remote command.");
+		await (await client(args.connectionId)).call("SendCommandToSession", [args.sessionId, args.command]);
+		return { accepted: true };
+	}));
+	server.registerTool("screenconnect_run_toolbox_item", {
+		description: "Queue an existing toolbox item on one remote session. Confirm the exact session and item. Acceptance does not prove execution.",
+		inputSchema: {
+			...session,
+			toolboxItemName: require_screenconnect_client.textField(512),
+			confirmSessionId: require_screenconnect_client.sessionIdField,
+			confirmToolboxItemName: require_screenconnect_client.textField(512)
+		},
+		annotations: actionAnnotations
+	}, (args) => guarded("run_toolbox_item", async () => {
+		if (args.confirmSessionId !== args.sessionId || args.confirmToolboxItemName !== args.toolboxItemName) throw new require_screenconnect_client.ScreenConnectError("Confirm the exact sessionId and toolboxItemName before running a toolbox item.");
+		await (await client(args.connectionId)).call("SendToolboxItemToSession", [args.sessionId, args.toolboxItemName]);
+		return { accepted: true };
+	}));
+}
+function boundedSessions(value, limit) {
+	if (!Array.isArray(value) || !value.every(require_screenconnect_client.isRecord)) throw new require_screenconnect_client.ScreenConnectError("ScreenConnect returned a malformed session list.");
+	return {
+		sessions: value.slice(0, limit),
+		returned: Math.min(value.length, limit),
+		total: value.length,
+		truncated: value.length > limit
+	};
+}
+const SERVER_VERSION = (0, node_module.createRequire)(require("url").pathToFileURL(__filename).href)("../package.json").version;
+const SERVER_NAME = "connectwise-screenconnect-mcp";
+function createServer(api, dependencies = {}) {
+	const server = new _modelcontextprotocol_sdk_server_mcp_js.McpServer({
+		name: SERVER_NAME,
+		version: SERVER_VERSION
+	});
+	registerTools(server, api, dependencies);
+	return server;
+}
+async function startServer(api, dependencies = {}) {
+	let client = api;
+	if (!client) {
+		const { apiKey, apiUrl } = (0, _alfe_ai_config.resolveConfig)();
+		client = new _alfe_ai_agent_api_client.AgentApiClient({
+			apiKey,
+			apiUrl
+		});
+	}
+	const server = createServer(client, dependencies);
+	try {
+		await server.connect(new _modelcontextprotocol_sdk_server_stdio_js.StdioServerTransport());
+		return server;
+	} catch (error) {
+		await server.close().catch(() => void 0);
+		throw error;
+	}
+}
+//#endregion
+Object.defineProperty(exports, "SERVER_NAME", {
+	enumerable: true,
+	get: function() {
+		return SERVER_NAME;
+	}
+});
+Object.defineProperty(exports, "SERVER_VERSION", {
+	enumerable: true,
+	get: function() {
+		return SERVER_VERSION;
+	}
+});
+Object.defineProperty(exports, "createServer", {
+	enumerable: true,
+	get: function() {
+		return createServer;
+	}
+});
+Object.defineProperty(exports, "startServer", {
+	enumerable: true,
+	get: function() {
+		return startServer;
+	}
+});

package/dist/server2.js

@@ -0,0 +1,263 @@
+import { a as ScreenConnectError, c as isRecord, d as safeErrorMessage, f as sessionIdField, i as PROVIDER, l as normalizeSiteUrl, n as ScreenConnectClient, o as connectionIdField, p as textField, s as customPropertiesField, u as parseCredentials } from "./screenconnect-client2.js";
+import { createRequire } from "node:module";
+import { z } from "zod";
+import { AgentApiClient } from "@alfe.ai/agent-api-client";
+import { resolveConfig } from "@alfe.ai/config";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+//#region src/tools.ts
+const readAnnotations = {
+	readOnlyHint: true,
+	destructiveHint: false,
+	idempotentHint: true,
+	openWorldHint: true
+};
+const addAnnotations = {
+	readOnlyHint: false,
+	destructiveHint: false,
+	idempotentHint: false,
+	openWorldHint: true
+};
+const updateAnnotations = {
+	readOnlyHint: false,
+	destructiveHint: true,
+	idempotentHint: true,
+	openWorldHint: true
+};
+const actionAnnotations = {
+	readOnlyHint: false,
+	destructiveHint: true,
+	idempotentHint: false,
+	openWorldHint: true
+};
+const selected = { connectionId: connectionIdField };
+const session = {
+	...selected,
+	sessionId: sessionIdField
+};
+const limitField = z.coerce.number().int().min(1).max(500).default(100);
+function registerTools(server, api, dependencies = {}) {
+	const createClient = dependencies.createClient ?? ((credentials) => new ScreenConnectClient(credentials));
+	const client = async (connectionId) => {
+		return createClient(parseCredentials(await api.getConnectionCredentials(connectionId), connectionId));
+	};
+	const guarded = async (operation, work) => {
+		try {
+			return { content: [{
+				type: "text",
+				text: JSON.stringify(await work())
+			}] };
+		} catch (error) {
+			const message = safeErrorMessage(error);
+			try {
+				dependencies.captureError?.(new Error(message), operation);
+			} catch {}
+			return {
+				isError: true,
+				content: [{
+					type: "text",
+					text: message
+				}]
+			};
+		}
+	};
+	server.registerTool("screenconnect_list_connections", {
+		description: "List authorized ScreenConnect connections and their exact connectionId selectors. Does not expose authentication secrets.",
+		inputSchema: {},
+		annotations: readAnnotations
+	}, () => guarded("list_connections", async () => {
+		const raw = await api.getConnectProviderAccounts(PROVIDER);
+		if (!isRecord(raw) || raw.provider !== "connectwise-screenconnect" || !Array.isArray(raw.accounts) || raw.accounts.length > 500) throw new ScreenConnectError("Invalid ScreenConnect connection list returned by Alfe.");
+		return { connections: raw.accounts.map((account) => {
+			const row = z.object({
+				connectionId: connectionIdField,
+				accountIdentifier: z.string().max(2048),
+				displayName: z.string().max(512).nullable().optional(),
+				siteUrl: z.string()
+			}).safeParse(account);
+			if (!row.success) throw new ScreenConnectError("Invalid ScreenConnect connection metadata returned by Alfe.");
+			return {
+				...row.data,
+				siteUrl: normalizeSiteUrl(row.data.siteUrl)
+			};
+		}) };
+	}));
+	server.registerTool("screenconnect_check_connection", {
+		description: "Verify authentication and the RESTful API Manager extension with an empty session filter. Does not change sessions.",
+		inputSchema: selected,
+		annotations: readAnnotations
+	}, (args) => guarded("check_connection", async () => {
+		boundedSessions(await (await client(args.connectionId)).call("GetSessionsByFilter", ["SessionID = '00000000-0000-0000-0000-000000000000'"]), 1);
+		return { connected: true };
+	}));
+	server.registerTool("screenconnect_list_sessions", {
+		description: "Find sessions with a required ScreenConnect session filter (for example SessionType = 'Access'). Limit bounds returned items only; the extension has no pagination. Narrow filters for large instances.",
+		inputSchema: {
+			...selected,
+			filter: textField(2048),
+			limit: limitField
+		},
+		annotations: readAnnotations
+	}, (args) => guarded("list_sessions", async () => boundedSessions(await (await client(args.connectionId)).call("GetSessionsByFilter", [args.filter]), args.limit)));
+	server.registerTool("screenconnect_find_sessions", {
+		description: "Look up sessions by name. Limit bounds returned items; the extension does not expose pagination.",
+		inputSchema: {
+			...selected,
+			name: textField(256),
+			limit: limitField
+		},
+		annotations: readAnnotations
+	}, (args) => guarded("find_sessions", async () => boundedSessions(await (await client(args.connectionId)).call("GetSessionsByName", [args.name]), args.limit)));
+	server.registerTool("screenconnect_get_session", {
+		description: "Get session data by its ScreenConnect session GUID.",
+		inputSchema: session,
+		annotations: readAnnotations
+	}, (args) => guarded("get_session", async () => (await client(args.connectionId)).call("GetSessionBySessionID", [args.sessionId])));
+	server.registerTool("screenconnect_get_session_details", {
+		description: "Get session details including events and connection history. Screenshot bytes are omitted.",
+		inputSchema: session,
+		annotations: readAnnotations
+	}, (args) => guarded("get_session_details", async () => {
+		const details = await (await client(args.connectionId)).call("GetSessionDetailsBySessionID", [args.sessionId]);
+		if (details === null) return null;
+		if (!isRecord(details)) throw new ScreenConnectError("ScreenConnect returned malformed session details.");
+		return Object.fromEntries(Object.entries(details).filter(([key]) => key !== "GuestScreenshotContent"));
+	}));
+	server.registerTool("screenconnect_create_session", {
+		description: "Create a Support or Meeting session. Access agents/installers are a separate ScreenConnect flow. Private sessions require a join code.",
+		inputSchema: {
+			...selected,
+			sessionType: z.enum(["Support", "Meeting"]),
+			name: textField(256),
+			isPublic: z.boolean().default(false),
+			code: z.string().max(128).default(""),
+			customProperties: customPropertiesField.default([])
+		},
+		annotations: addAnnotations
+	}, (args) => guarded("create_session", async () => {
+		if (!args.isPublic && !args.code.trim()) throw new ScreenConnectError("Private ScreenConnect sessions require a join code.");
+		return (await client(args.connectionId)).call("CreateSession", [
+			args.sessionType,
+			args.name,
+			args.isPublic,
+			args.code,
+			args.customProperties
+		]);
+	}));
+	server.registerTool("screenconnect_rename_session", {
+		description: "Replace the display name of one ScreenConnect session.",
+		inputSchema: {
+			...session,
+			name: textField(256)
+		},
+		annotations: updateAnnotations
+	}, (args) => guarded("rename_session", async () => {
+		await (await client(args.connectionId)).call("UpdateSessionName", [args.sessionId, args.name]);
+		return { updated: true };
+	}));
+	server.registerTool("screenconnect_update_custom_properties", {
+		description: "Replace all custom property values in positional order (up to eight). Read the session first and retain any values that should remain.",
+		inputSchema: {
+			...session,
+			customProperties: customPropertiesField
+		},
+		annotations: updateAnnotations
+	}, (args) => guarded("update_custom_properties", async () => {
+		await (await client(args.connectionId)).call("UpdateSessionCustomProperties", [args.sessionId, args.customProperties]);
+		return { updated: true };
+	}));
+	server.registerTool("screenconnect_add_note", {
+		description: "Append a note to one ScreenConnect session (RESTful API Manager 1.0.6 or newer).",
+		inputSchema: {
+			...session,
+			note: textField(16384)
+		},
+		annotations: addAnnotations
+	}, (args) => guarded("add_note", async () => {
+		await (await client(args.connectionId)).call("AddNoteToSession", [args.sessionId, args.note]);
+		return { accepted: true };
+	}));
+	server.registerTool("screenconnect_send_message", {
+		description: "Send a chat message to one session, attributed to the specified host name.",
+		inputSchema: {
+			...session,
+			byHost: textField(256),
+			message: textField(16384)
+		},
+		annotations: addAnnotations
+	}, (args) => guarded("send_message", async () => {
+		await (await client(args.connectionId)).call("SendMessageToSession", [
+			args.sessionId,
+			args.byHost,
+			args.message
+		]);
+		return { accepted: true };
+	}));
+	server.registerTool("screenconnect_run_command", {
+		description: "Queue a command on the selected remote session. Confirm the exact session and command. Acceptance does not prove execution; inspect session details for results before retrying.",
+		inputSchema: {
+			...session,
+			command: textField(32768),
+			confirmSessionId: sessionIdField,
+			confirmCommand: textField(32768)
+		},
+		annotations: actionAnnotations
+	}, (args) => guarded("run_command", async () => {
+		if (args.confirmSessionId !== args.sessionId || args.confirmCommand !== args.command) throw new ScreenConnectError("Confirm the exact sessionId and command before running a remote command.");
+		await (await client(args.connectionId)).call("SendCommandToSession", [args.sessionId, args.command]);
+		return { accepted: true };
+	}));
+	server.registerTool("screenconnect_run_toolbox_item", {
+		description: "Queue an existing toolbox item on one remote session. Confirm the exact session and item. Acceptance does not prove execution.",
+		inputSchema: {
+			...session,
+			toolboxItemName: textField(512),
+			confirmSessionId: sessionIdField,
+			confirmToolboxItemName: textField(512)
+		},
+		annotations: actionAnnotations
+	}, (args) => guarded("run_toolbox_item", async () => {
+		if (args.confirmSessionId !== args.sessionId || args.confirmToolboxItemName !== args.toolboxItemName) throw new ScreenConnectError("Confirm the exact sessionId and toolboxItemName before running a toolbox item.");
+		await (await client(args.connectionId)).call("SendToolboxItemToSession", [args.sessionId, args.toolboxItemName]);
+		return { accepted: true };
+	}));
+}
+function boundedSessions(value, limit) {
+	if (!Array.isArray(value) || !value.every(isRecord)) throw new ScreenConnectError("ScreenConnect returned a malformed session list.");
+	return {
+		sessions: value.slice(0, limit),
+		returned: Math.min(value.length, limit),
+		total: value.length,
+		truncated: value.length > limit
+	};
+}
+const SERVER_VERSION = createRequire(import.meta.url)("../package.json").version;
+const SERVER_NAME = "connectwise-screenconnect-mcp";
+function createServer(api, dependencies = {}) {
+	const server = new McpServer({
+		name: SERVER_NAME,
+		version: SERVER_VERSION
+	});
+	registerTools(server, api, dependencies);
+	return server;
+}
+async function startServer(api, dependencies = {}) {
+	let client = api;
+	if (!client) {
+		const { apiKey, apiUrl } = resolveConfig();
+		client = new AgentApiClient({
+			apiKey,
+			apiUrl
+		});
+	}
+	const server = createServer(client, dependencies);
+	try {
+		await server.connect(new StdioServerTransport());
+		return server;
+	} catch (error) {
+		await server.close().catch(() => void 0);
+		throw error;
+	}
+}
+//#endregion
+export { startServer as i, SERVER_VERSION as n, createServer as r, SERVER_NAME as t };

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@alfe.ai/connectwise-screenconnect-mcp",
+  "version": "0.1.0",
+  "description": "ScreenConnect session management through the RESTful API Manager extension and Alfe connections",
+  "type": "module",
+  "main": "./dist/server.js",
+  "types": "./dist/server.d.ts",
+  "bin": {
+    "connectwise-screenconnect-mcp": "./dist/bin.js"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/server.d.ts",
+      "import": "./dist/server.js",
+      "require": "./dist/server.cjs"
+    },
+    "./client": {
+      "types": "./dist/screenconnect-client.d.ts",
+      "import": "./dist/screenconnect-client.js",
+      "require": "./dist/screenconnect-client.cjs"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "zod": "^4.0.5",
+    "@alfe.ai/agent-api-client": "0.19.0",
+    "@alfe.ai/config": "0.4.1"
+  },
+  "license": "UNLICENSED",
+  "homepage": "https://alfe.ai",
+  "author": "Alfe (https://alfe.ai)",
+  "keywords": [
+    "alfe",
+    "mcp",
+    "screenconnect",
+    "connectwise",
+    "remote-support"
+  ],
+  "scripts": {
+    "build": "tsdown",
+    "dev": "tsdown --watch",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint .",
+    "test": "vitest run"
+  }
+}