@usex/mikrotik-mcp 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,153 @@
+import { z } from "zod";
+/** Connection details for a single MikroTik device. */
+declare const DeviceConfigSchema: unknown;
+type DeviceConfig = z.infer<typeof DeviceConfigSchema>;
+declare const MikrotikConfigSchema: unknown;
+type MikrotikConfig = z.infer<typeof MikrotikConfigSchema>;
+/**
+* Build the effective configuration from the environment and CLI flags.
+* `argv` defaults to the process arguments (after `bun run <file>`).
+*/
+declare function loadConfig(argv?: string[]): MikrotikConfig;
+interface ToolContext {
+	/** Informational progress message. */
+	info: (message: string) => void;
+	/** Error / failure message. */
+	error: (message: string) => void;
+	/**
+	* Name of the device this call targets, when the client selected one.
+	* `undefined` means "use the configured default device".
+	*/
+	device?: string;
+}
+type SendLog = (level: "info" | "error", message: string) => void;
+/**
+* Execute a RouterOS command and return its raw text output.
+*
+* The target device is taken from `ctx.device` (set by the registry from the
+* tool call's `device` argument); when unset, the configured default is used.
+* Safe Mode is tracked per device, so each router has its own session.
+*
+* @param command  Fully-formed RouterOS CLI command (e.g. `/ip address print`).
+* @param ctx      Per-call context carrying the target device.
+*/
+declare function executeMikrotikCommand(command: string, ctx: ToolContext): Promise<string>;
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { ToolAnnotations } from "@modelcontextprotocol/sdk/types.js";
+import { ZodRawShape } from "zod";
+/** Options threaded into every tool registration. */
+interface RegisterOptions {
+	sendLog?: SendLog;
+	/** Configured device names; when more than one, a `device` selector is injected. */
+	deviceNames?: string[];
+}
+interface ToolDef<Shape extends ZodRawShape> {
+	/** Stable tool id exposed to MCP clients. */
+	name: string;
+	/** Short human-readable display name shown in compact tool lists. */
+	title: string;
+	/** Full description — this is the prompt the model reads to decide when to call. */
+	description: string;
+	/** One of the risk presets above. */
+	annotations: ToolAnnotations;
+	/** Zod raw shape describing the tool's parameters. */
+	inputSchema?: Shape;
+	/** Handler returning the textual result shown to the model. */
+	handler: (args: any, ctx: ToolContext) => Promise<string> | string;
+}
+interface RegisterableTool {
+	name: string;
+	title: string;
+	annotations: ToolAnnotations;
+	inputSchema?: ZodRawShape;
+	description: string;
+	register: (server: McpServer, opts?: RegisterOptions) => void;
+}
+declare function defineTool<Shape extends ZodRawShape>(def: ToolDef<Shape>): RegisterableTool;
+type ToolModule = RegisterableTool[];
+/** Register every tool from every module, returning the total count. */
+declare function registerTools(server: McpServer, modules: ToolModule[], opts?: RegisterOptions): number;
+declare function setConfig(cfg: MikrotikConfig): void;
+declare function getConfig(): MikrotikConfig;
+/** Names of every configured device, plus which one is the default. */
+declare function listDevices(): {
+	names: string[];
+	default: string;
+};
+/** Resolve a (possibly undefined) device name to a concrete, existing name. */
+declare function resolveDeviceName(name?: string): string;
+/**
+* Return the connection config for a device by name (or the default when
+* `name` is undefined). Throws if an explicit, unknown name is given.
+*/
+declare function getDevice(name?: string): DeviceConfig;
+import { McpServer as McpServer2 } from "@modelcontextprotocol/sdk/server/mcp.js";
+interface CreatedServer {
+	server: McpServer2;
+	toolCount: number;
+	promptCount: number;
+}
+declare function createServer(opts?: {
+	sendLog?: SendLog;
+}): CreatedServer;
+import { ClientChannel } from "ssh2";
+interface SSHClientOptions {
+	host: string;
+	username: string;
+	password?: string;
+	port?: number;
+	keyFilename?: string;
+	privateKey?: string;
+	/** Passphrase for an encrypted private key. */
+	keyPassphrase?: string;
+	timeoutMs?: number;
+}
+declare class MikroTikSSHClient {
+	private client;
+	private readonly opts;
+	/** Human-readable reason the last `connect()` failed, if it did. */
+	lastError?: string;
+	constructor(opts: SSHClientOptions);
+	/** Establish the SSH connection. Resolves `true` on success, `false` on failure. */
+	connect(): Promise<boolean>;
+	/** Run a single command on a fresh SSH channel and return its decoded output. */
+	run(command: string): Promise<string>;
+	/** Open a persistent interactive shell channel (used by Safe Mode). */
+	shell(opts?: {
+		term?: string;
+		cols?: number;
+		rows?: number;
+	}): Promise<ClientChannel>;
+	/** Close the SSH connection. Safe to call multiple times. */
+	disconnect(): void;
+}
+declare class SafeModeManager {
+	private readonly deviceName;
+	private ssh;
+	private channel;
+	private active;
+	/** Serializes channel access so concurrent tool calls don't interleave I/O. */
+	private queue;
+	/** The device this Safe Mode session belongs to (a configured device name). */
+	constructor(deviceName: string);
+	get isActive(): boolean;
+	/** Run `fn` exclusively — the persistent channel must not be shared mid-command. */
+	private lock;
+	/** Open a persistent SSH shell and activate MikroTik Safe Mode. */
+	enable(): Promise<string>;
+	/** Execute a command through the safe-mode persistent shell session. */
+	execute(command: string): Promise<string>;
+	/** Send Ctrl+X again to exit Safe Mode and persist all changes. */
+	commit(): Promise<string>;
+	/** Close the session to trigger MikroTik's automatic safe-mode revert. */
+	rollback(): Promise<string>;
+	status(): string;
+	private readUntilPrompt;
+	private extractOutput;
+	private cleanup;
+}
+declare function getSafeModeManager(deviceName: string): SafeModeManager;
+declare const allToolModules: ToolModule[];
+declare const VERSION: string;
+declare const SERVER_NAME = "mcp-mikrotik";
+export { setConfig, resolveDeviceName, registerTools, loadConfig, listDevices, getSafeModeManager, getDevice, getConfig, executeMikrotikCommand, defineTool, createServer, allToolModules, VERSION, ToolModule, ToolContext, SafeModeManager, SERVER_NAME, RegisterableTool, MikrotikConfigSchema, MikrotikConfig, MikroTikSSHClient, DeviceConfigSchema, DeviceConfig };