@akms/mcp-ssh 0.0.1 → 0.0.2

package/lib/index.js

@@ -1,22 +1,17 @@
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import os from 'os';
-import path3 from 'path';
-import fs from 'fs';
-import { z } from 'zod';
+import path2 from 'path';
+import fs2 from 'fs';
 import { createHash } from 'crypto';
 import { StringDecoder } from 'string_decoder';
 import ssh2 from 'ssh2';
 import { setInterval, clearInterval } from 'timers';
+import { z } from 'zod';
 
 // src/server.ts
 
 // src/_defs/defaults.ts
-var CONFIG_PATH_ENV = "SSH_MCP_CONFIG";
 var LOG_LEVEL_ENV = "SSH_MCP_LOG_LEVEL";
-var DEFAULT_CONFIG_FILENAMES = [
-  ".akms-ssh.json",
-  ".config/akms-ssh/config.json"
-];
 var DEFAULT_SSH_PORT = 22;
 var DEFAULT_EXEC_TIMEOUT_MS = 6e4;
 var DEFAULT_CONNECT_TIMEOUT_MS = 2e4;
@@ -27,8 +22,8 @@ var SESSION_IDLE_TIMEOUT_MS = 15 * 60 * 1e3;
 var SESSION_SWEEP_INTERVAL_MS = 6e4;
 var CWD_MARKER = "__AKMS_SSH_CWD__";
 var MAX_DIRECTORY_ENTRIES = 1e3;
-var SERVER_NAME = "akms-ssh";
-var SERVER_VERSION = "0.0.1";
+var SERVER_NAME = "akms-mcp-ssh";
+var SERVER_VERSION = "0.0.2";
 
 // src/_defs/command-rules.ts
 var CRITICAL_PATH_PATTERN = new RegExp(
@@ -411,10 +406,6 @@ var PROTECTED_LOCAL_PATH_RULES = [
     pattern: /(^|\/)\.netrc$/i,
     reason: "netrc credentials"
   },
-  {
-    pattern: /(^|\/)\.?akms-ssh(\.json)?(\/|$)/i,
-    reason: "this server's own host profile configuration"
-  },
   {
     pattern: /(^|\/)\.claude(\.json)?(\/|$)/i,
     reason: "MCP client configuration"
@@ -439,7 +430,7 @@ var PROTECTED_LOCAL_PATH_RULES = [
 
 // src/_defs/env-vars.ts
 var SINGLE_HOST_ENV = {
-  /** Presence of this variable selects single-host mode. */
+  /** Presence of this variable is what registers a host at all. */
   HOST: "SSH_HOST",
   PORT: "SSH_PORT",
   USER: "SSH_USER",
@@ -585,15 +576,15 @@ function expandHomePath(inputPath) {
   if (inputPath === "~") {
     expanded = os.homedir();
   } else if (inputPath.startsWith("~/") == true || inputPath.startsWith("~\\") == true) {
-    expanded = path3.join(os.homedir(), inputPath.slice(2));
+    expanded = path2.join(os.homedir(), inputPath.slice(2));
   }
-  return path3.resolve(expanded);
+  return path2.resolve(expanded);
 }
 function isAbsoluteRemotePath(remotePath) {
   return remotePath.startsWith("/");
 }
 function normalizeRemotePath(remotePath) {
-  return path3.posix.normalize(remotePath);
+  return path2.posix.normalize(remotePath);
 }
 function isRemotePathWithin(candidate, allowedPrefix) {
   const normalizedCandidate = normalizeRemotePath(candidate);
@@ -606,43 +597,6 @@ function isRemotePathWithin(candidate, allowedPrefix) {
   }
   return normalizedCandidate.startsWith(`${normalizedPrefix}/`);
 }
-var POLICY_INPUT_SCHEMA = z.strictObject({
-  readonly: z.boolean().optional(),
-  allowSudo: z.boolean().optional(),
-  execTimeoutMs: z.number().int().positive().optional(),
-  connectTimeoutMs: z.number().int().positive().optional(),
-  maxOutputCharacters: z.number().int().positive().optional(),
-  maxReadFileBytes: z.number().int().positive().optional(),
-  allowCommands: z.array(z.string()).optional(),
-  denyPatterns: z.array(z.string()).optional(),
-  allowedPaths: z.array(z.string()).optional()
-});
-var HOST_INPUT_SCHEMA = POLICY_INPUT_SCHEMA.extend({
-  // Kept strict by `.extend()` on a strict base — verified by the config tests.
-  host: z.string().min(1),
-  port: z.number().int().min(1).max(65535).optional(),
-  username: z.string().min(1),
-  description: z.string().optional(),
-  privateKeyPath: z.string().optional(),
-  privateKey: z.string().optional(),
-  passphrase: z.string().optional(),
-  /** Name of an env var holding the passphrase, preferred over inlining it. */
-  passphraseEnv: z.string().optional(),
-  password: z.string().optional(),
-  /** Name of an env var holding the password, preferred over inlining it. */
-  passwordEnv: z.string().optional(),
-  /** Pinned server host key, e.g. "SHA256:abc123…". */
-  hostKeyFingerprint: z.string().optional(),
-  defaultCwd: z.string().optional()
-});
-var CONFIG_INPUT_SCHEMA = z.strictObject({
-  /** Ignored at runtime; present so editors can attach a JSON schema. */
-  $schema: z.string().optional(),
-  defaults: POLICY_INPUT_SCHEMA.optional(),
-  hosts: z.record(z.string(), HOST_INPUT_SCHEMA)
-});
-
-// src/modules/config/env-host.ts
 function readEnv(name) {
   const value = process.env[name];
   if (value == null) {
@@ -690,220 +644,84 @@ function readListEnv(name) {
   }
   return items;
 }
-function buildConfigFromEnv() {
-  const host = readEnv(SINGLE_HOST_ENV.HOST);
-  if (host == null) {
-    return null;
-  }
-  const username = readEnv(SINGLE_HOST_ENV.USER);
-  if (username == null) {
-    throw new Error(`${SINGLE_HOST_ENV.HOST} is set, so ${SINGLE_HOST_ENV.USER} is required`);
-  }
-  const hostInput = {
-    host,
-    username,
-    port: readIntegerEnv(SINGLE_HOST_ENV.PORT),
-    description: readEnv(SINGLE_HOST_ENV.DESCRIPTION),
-    privateKeyPath: readEnv(SINGLE_HOST_ENV.KEY),
-    passphrase: readEnv(SINGLE_HOST_ENV.PASSPHRASE),
-    password: readEnv(SINGLE_HOST_ENV.PASSWORD),
-    hostKeyFingerprint: readEnv(SINGLE_HOST_ENV.HOST_KEY),
-    defaultCwd: readEnv(SINGLE_HOST_ENV.CWD),
-    readonly: readBooleanEnv(SINGLE_HOST_ENV.READONLY),
-    allowSudo: readBooleanEnv(SINGLE_HOST_ENV.ALLOW_SUDO),
-    allowCommands: readListEnv(SINGLE_HOST_ENV.ALLOW_COMMANDS),
-    denyPatterns: readListEnv(SINGLE_HOST_ENV.DENY_PATTERNS),
-    allowedPaths: readListEnv(SINGLE_HOST_ENV.ALLOWED_PATHS),
-    execTimeoutMs: readIntegerEnv(SINGLE_HOST_ENV.EXEC_TIMEOUT_MS),
-    connectTimeoutMs: readIntegerEnv(SINGLE_HOST_ENV.CONNECT_TIMEOUT_MS),
-    maxOutputCharacters: readIntegerEnv(SINGLE_HOST_ENV.MAX_OUTPUT_CHARACTERS),
-    maxReadFileBytes: readIntegerEnv(SINGLE_HOST_ENV.MAX_READ_FILE_BYTES)
-  };
-  const name = readEnv(SINGLE_HOST_ENV.NAME) ?? host;
-  const _logger = $logger.child({ context: "buildConfigFromEnv", profile: name });
-  _logger.debug("single-host config assembled from environment variables");
-  return { hosts: { [name]: hostInput } };
-}
-
-// src/modules/config/load-config.ts
-function resolveConfigSource(explicitPath) {
-  if (explicitPath != null && explicitPath.trim() !== "") {
-    return { kind: "file", path: expandHomePath(explicitPath) };
-  }
-  const fromSingleHostEnv = buildConfigFromEnv();
-  if (fromSingleHostEnv != null) {
-    return { kind: "env", config: fromSingleHostEnv };
-  }
-  const fromEnv = process.env[CONFIG_PATH_ENV];
-  if (fromEnv != null && fromEnv.trim() !== "") {
-    const trimmedValue = fromEnv.trim();
-    if (trimmedValue.startsWith("{") == true) {
-      return { kind: "inline", json: trimmedValue };
-    }
-    return { kind: "file", path: expandHomePath(trimmedValue) };
-  }
-  for (const filename of DEFAULT_CONFIG_FILENAMES) {
-    const candidate = path3.join(os.homedir(), filename);
-    if (fs.existsSync(candidate) == true) {
-      return { kind: "file", path: candidate };
-    }
-  }
-  return { kind: "none" };
-}
-function compileDenyPatterns(profileName, sources) {
+function compileDenyPatterns(sources) {
   return sources.map((source) => {
     try {
       return new RegExp(source, "i");
     } catch (ex) {
-      const _logger = $logger.child({ context: "compileDenyPatterns", profile: profileName });
+      const _logger = $logger.child({ context: "compileDenyPatterns" });
       _logger.error(ex, "denyPatterns entry is not a valid regular expression");
       let detail = String(ex);
       if (ex instanceof Error) {
         detail = ex.message;
       }
-      throw new Error(`profile '${profileName}' has an invalid denyPatterns entry /${source}/: ${detail}`);
+      throw new Error(`${SINGLE_HOST_ENV.DENY_PATTERNS} has an invalid entry /${source}/: ${detail}`);
     }
   });
 }
-function resolvePolicy(profileName, defaults, override) {
-  const allowCommands = [...override.allowCommands ?? defaults?.allowCommands ?? []];
-  if (allowCommands.length > 0 && allowCommands.includes("pwd") == false) {
-    allowCommands.push("pwd");
+function loadHostProfile() {
+  const host = readEnv(SINGLE_HOST_ENV.HOST);
+  if (host == null) {
+    const _startupLogger = $logger.child({ context: "loadHostProfile" });
+    _startupLogger.warn("no host is registered; set the connection variables and restart", {
+      env_vars: [SINGLE_HOST_ENV.HOST, SINGLE_HOST_ENV.USER]
+    });
+    return null;
   }
-  const denyPatternSources = override.denyPatterns ?? defaults?.denyPatterns ?? [];
-  const allowedPaths = override.allowedPaths ?? defaults?.allowedPaths ?? [];
-  const _logger = $logger.child({ context: "resolvePolicy", profile: profileName });
-  if (override.allowCommands?.length === 0 && (defaults?.allowCommands?.length ?? 0) > 0) {
-    _logger.warn("host sets allowCommands to an empty list, which removes the restriction from defaults");
+  const username = readEnv(SINGLE_HOST_ENV.USER);
+  if (username == null) {
+    throw new Error(`${SINGLE_HOST_ENV.HOST} is set, so ${SINGLE_HOST_ENV.USER} is required`);
   }
-  if (override.allowedPaths?.length === 0 && (defaults?.allowedPaths?.length ?? 0) > 0) {
-    _logger.warn("host sets allowedPaths to an empty list, which removes the restriction from defaults");
+  const name = readEnv(SINGLE_HOST_ENV.NAME) ?? host;
+  const _logger = $logger.child({ context: "loadHostProfile", profile: name });
+  const allowCommands = readListEnv(SINGLE_HOST_ENV.ALLOW_COMMANDS) ?? [];
+  if (allowCommands.length > 0 && allowCommands.includes("pwd") == false) {
+    allowCommands.push("pwd");
   }
-  return {
-    readonly: override.readonly ?? defaults?.readonly ?? false,
-    allowSudo: override.allowSudo ?? defaults?.allowSudo ?? true,
-    execTimeoutMs: override.execTimeoutMs ?? defaults?.execTimeoutMs ?? DEFAULT_EXEC_TIMEOUT_MS,
-    connectTimeoutMs: override.connectTimeoutMs ?? defaults?.connectTimeoutMs ?? DEFAULT_CONNECT_TIMEOUT_MS,
-    maxOutputCharacters: override.maxOutputCharacters ?? defaults?.maxOutputCharacters ?? DEFAULT_MAX_OUTPUT_CHARACTERS,
-    maxReadFileBytes: override.maxReadFileBytes ?? defaults?.maxReadFileBytes ?? DEFAULT_MAX_READ_FILE_BYTES,
+  const policy = {
+    readonly: readBooleanEnv(SINGLE_HOST_ENV.READONLY) ?? false,
+    allowSudo: readBooleanEnv(SINGLE_HOST_ENV.ALLOW_SUDO) ?? true,
+    execTimeoutMs: readIntegerEnv(SINGLE_HOST_ENV.EXEC_TIMEOUT_MS) ?? DEFAULT_EXEC_TIMEOUT_MS,
+    connectTimeoutMs: readIntegerEnv(SINGLE_HOST_ENV.CONNECT_TIMEOUT_MS) ?? DEFAULT_CONNECT_TIMEOUT_MS,
+    maxOutputCharacters: readIntegerEnv(SINGLE_HOST_ENV.MAX_OUTPUT_CHARACTERS) ?? DEFAULT_MAX_OUTPUT_CHARACTERS,
+    maxReadFileBytes: readIntegerEnv(SINGLE_HOST_ENV.MAX_READ_FILE_BYTES) ?? DEFAULT_MAX_READ_FILE_BYTES,
     allowCommands,
-    denyPatterns: compileDenyPatterns(profileName, denyPatternSources),
-    allowedPaths
+    denyPatterns: compileDenyPatterns(readListEnv(SINGLE_HOST_ENV.DENY_PATTERNS) ?? []),
+    allowedPaths: readListEnv(SINGLE_HOST_ENV.ALLOWED_PATHS) ?? []
   };
-}
-function resolveSecret(profileName, inlineValue, envVarName) {
-  if (envVarName == null) {
-    return inlineValue;
-  }
-  const fromEnv = process.env[envVarName];
-  if (fromEnv == null || fromEnv === "") {
-    const _logger = $logger.child({ context: "resolveSecret", profile: profileName, env_var: envVarName });
-    _logger.warn("env var referenced by the profile is empty; falling back to the inline value");
-    return inlineValue;
-  }
-  return fromEnv;
-}
-function toHostProfile(name, raw, defaults) {
   const profile = {
     name,
-    host: raw.host,
-    port: raw.port ?? DEFAULT_SSH_PORT,
-    username: raw.username,
-    description: raw.description,
-    privateKey: raw.privateKey,
-    passphrase: resolveSecret(name, raw.passphrase, raw.passphraseEnv),
-    password: resolveSecret(name, raw.password, raw.passwordEnv),
-    hostKeyFingerprint: raw.hostKeyFingerprint,
-    defaultCwd: raw.defaultCwd,
-    policy: resolvePolicy(name, defaults, raw)
+    host,
+    port: readIntegerEnv(SINGLE_HOST_ENV.PORT) ?? DEFAULT_SSH_PORT,
+    username,
+    description: readEnv(SINGLE_HOST_ENV.DESCRIPTION),
+    passphrase: readEnv(SINGLE_HOST_ENV.PASSPHRASE),
+    password: readEnv(SINGLE_HOST_ENV.PASSWORD),
+    hostKeyFingerprint: readEnv(SINGLE_HOST_ENV.HOST_KEY),
+    defaultCwd: readEnv(SINGLE_HOST_ENV.CWD),
+    policy
   };
-  if (raw.privateKeyPath != null) {
-    const expandedKeyPath = expandHomePath(raw.privateKeyPath);
+  const keyPath = readEnv(SINGLE_HOST_ENV.KEY);
+  if (keyPath != null) {
+    const expandedKeyPath = expandHomePath(keyPath);
     profile.privateKeyPath = expandedKeyPath;
-    if (fs.existsSync(expandedKeyPath) == false) {
-      const _logger = $logger.child({ context: "toHostProfile", profile: name });
-      _logger.warn("privateKeyPath does not exist; connections for this profile will fail", {
+    if (fs2.existsSync(expandedKeyPath) == false) {
+      _logger.warn(`${SINGLE_HOST_ENV.KEY} does not exist; connections will fail`, {
         private_key_path: expandedKeyPath
       });
     }
   }
-  return profile;
-}
-function warnOnLoosePermissions(configPath) {
-  if (process.platform === "win32") {
-    return;
-  }
-  const stats = fs.statSync(configPath);
-  const permissionBits = stats.mode & 511;
-  if ((permissionBits & 63) === 0) {
-    return;
-  }
-  const _logger = $logger.child({ context: "warnOnLoosePermissions", config_path: configPath });
-  _logger.warn(`config file is readable by other users, run: chmod 600 ${configPath}`, {
-    mode: permissionBits.toString(8)
-  });
-}
-function loadConfig(explicitPath) {
-  let _logger = $logger.child({ context: "loadConfig" });
-  const source = resolveConfigSource(explicitPath);
-  if (source.kind === "none") {
-    _logger.warn("no config found; no host profiles are registered", {
-      searched: DEFAULT_CONFIG_FILENAMES,
-      env_vars: [SINGLE_HOST_ENV.HOST, CONFIG_PATH_ENV]
-    });
-    return { profiles: /* @__PURE__ */ new Map(), sourcePath: null, sourceLabel: "none" };
-  }
-  let parsedJson = null;
-  let sourcePath = null;
-  let sourceLabel = `inline ${CONFIG_PATH_ENV}`;
-  if (source.kind === "env") {
-    _logger = _logger.child({ config_source: "env" });
-    sourceLabel = `${SINGLE_HOST_ENV.HOST} environment variables`;
-    parsedJson = source.config;
-  } else {
-    let rawText = "";
-    if (source.kind === "inline") {
-      _logger = _logger.child({ config_source: "inline" });
-      rawText = source.json;
-    } else {
-      _logger = _logger.child({ config_path: source.path });
-      sourcePath = source.path;
-      sourceLabel = source.path;
-      if (fs.existsSync(source.path) == false) {
-        _logger.error(null, "config file does not exist");
-        throw new Error(`ssh mcp config not found: ${source.path}`);
-      }
-      rawText = fs.readFileSync(source.path, "utf8");
-    }
-    try {
-      parsedJson = JSON.parse(rawText);
-    } catch (ex) {
-      _logger.error(ex, "config is not valid json");
-      throw new Error(`ssh mcp config is not valid JSON (${sourceLabel})`);
-    }
-  }
-  const validated = CONFIG_INPUT_SCHEMA.safeParse(parsedJson);
-  if (validated.success == false) {
-    const issueSummary = validated.error.issues.map((issue) => `${issue.path.join(".")}: ${issue.message}`).join("; ");
-    _logger.error(validated.error, "config failed schema validation");
-    throw new Error(`ssh mcp config is invalid (${sourceLabel}): ${issueSummary}`);
-  }
-  if (sourcePath != null) {
-    warnOnLoosePermissions(sourcePath);
-  }
-  const profiles = /* @__PURE__ */ new Map();
-  for (const [name, hostInput] of Object.entries(validated.data.hosts)) {
-    profiles.set(name, toHostProfile(name, hostInput, validated.data.defaults));
-  }
-  _logger.info("config loaded", {
-    profile_count: profiles.size,
-    profiles: Array.from(profiles.keys())
+  _logger.info("host profile loaded", {
+    host,
+    port: profile.port,
+    username,
+    readonly: policy.readonly
   });
-  return { profiles, sourcePath, sourceLabel };
+  return profile;
 }
 function toHostSummary(profile) {
   let authMethod = "agent";
-  if (profile.privateKeyPath != null || profile.privateKey != null) {
+  if (profile.privateKeyPath != null) {
     authMethod = "privateKey";
   } else if (profile.password != null) {
     authMethod = "password";
@@ -1358,20 +1176,20 @@ function inspectRemotePath(remotePath, policy, access) {
 function toRealPath(inputPath) {
   const _logger = $logger.child({ context: "toRealPath" });
   try {
-    return fs.realpathSync.native(inputPath);
+    return fs2.realpathSync.native(inputPath);
   } catch (ex) {
     _logger.debug("path does not resolve, falling back to its parent directory", {
       reason: ex instanceof Error ? ex.name : "unknown"
     });
   }
   try {
-    const parentRealPath = fs.realpathSync.native(path3.dirname(inputPath));
-    return path3.join(parentRealPath, path3.basename(inputPath));
+    const parentRealPath = fs2.realpathSync.native(path2.dirname(inputPath));
+    return path2.join(parentRealPath, path2.basename(inputPath));
   } catch (ex) {
     _logger.debug("parent directory does not resolve either, comparing lexically", {
       reason: ex instanceof Error ? ex.name : "unknown"
     });
-    return path3.resolve(inputPath);
+    return path2.resolve(inputPath);
   }
 }
 function toComparablePath(inputPath) {
@@ -1457,7 +1275,7 @@ function readPrivateKey(profile, keyPath) {
     return cached;
   }
   try {
-    const contents = fs.readFileSync(keyPath);
+    const contents = fs2.readFileSync(keyPath);
     PRIVATE_KEY_CACHE.set(keyPath, contents);
     return contents;
   } catch (ex) {
@@ -1503,8 +1321,6 @@ function buildConnectConfig(profile, onHostKeySeen) {
   };
   if (profile.privateKeyPath != null) {
     connectConfig.privateKey = readPrivateKey(profile, profile.privateKeyPath);
-  } else if (profile.privateKey != null) {
-    connectConfig.privateKey = profile.privateKey;
   }
   if (profile.passphrase != null) {
     connectConfig.passphrase = profile.passphrase;
@@ -1521,7 +1337,7 @@ function buildRemoteCommand(command, cwd, trackCwd) {
   const lines = [];
   if (cwd != null && cwd !== "") {
     const quotedCwd = quoteShellArgument(cwd);
-    lines.push(`cd ${quotedCwd} 2>/dev/null || { echo 'akms-ssh: cannot enter the requested working directory' >&2; exit 1; }`);
+    lines.push(`cd ${quotedCwd} 2>/dev/null || { echo 'akms-mcp-ssh: cannot enter the requested working directory' >&2; exit 1; }`);
   }
   lines.push(command);
   if (trackCwd == true) {
@@ -2234,7 +2050,7 @@ async function writeRemoteFile(connection, args) {
 }
 async function uploadFile(connection, localPath, remotePath) {
   requirePermittedPath(connection, remotePath, "write");
-  const localStats = fs.statSync(localPath);
+  const localStats = fs2.statSync(localPath);
   if (localStats.isFile() == false) {
     throw new Error(`local path is not a file: ${localPath}`);
   }
@@ -2271,7 +2087,7 @@ async function downloadFile(connection, remotePath, localPath) {
       });
     });
   });
-  const localStats = fs.statSync(localPath);
+  const localStats = fs2.statSync(localPath);
   const _logger = $logger.child({
     context: "downloadFile",
     profile: connection.profile.name,
@@ -2289,44 +2105,42 @@ var ENTRY_TYPE_MARKERS = {
   symlink: "l",
   other: "?"
 };
-function formatHostList(config) {
-  if (config.profiles.size === 0) {
+function formatHostProfile(profile) {
+  if (profile == null) {
     return [
-      "No SSH host profiles are registered.",
+      "No SSH host is registered.",
       "",
-      `Put them in this server's MCP entry \u2014 ${CONFIG_PATH_ENV} takes the JSON itself:`,
+      "Put the connection in this server's MCP entry \u2014 one server entry per host:",
       "",
       `    "env": {`,
-      `        "${CONFIG_PATH_ENV}": "{\\"hosts\\":{\\"my-server\\":{\\"host\\":\\"10.0.0.5\\",\\"username\\":\\"deploy\\",\\"privateKeyPath\\":\\"~/.ssh/id_ed25519\\"}}}"`,
+      `        "${SINGLE_HOST_ENV.HOST}": "10.0.0.5",`,
+      `        "${SINGLE_HOST_ENV.USER}": "deploy",`,
+      `        "${SINGLE_HOST_ENV.KEY}": "~/.ssh/id_ed25519"`,
       "    }",
       "",
-      `It also accepts a path to a JSON file, and ~/${DEFAULT_CONFIG_FILENAMES[0]} is picked up automatically.`,
-      "Restart this server after changing it."
+      `${SINGLE_HOST_ENV.HOST} and ${SINGLE_HOST_ENV.USER} are the whole minimum.`,
+      "Restart this server after changing it \u2014 environment variables are fixed for the life of the process."
     ].join("\n");
   }
+  const summary = toHostSummary(profile);
+  let accessLabel = "writable";
+  if (summary.readonly == true) {
+    accessLabel = "READ-ONLY";
+  }
+  let sudoLabel = "sudo=disabled";
+  if (summary.allowSudo == true) {
+    sudoLabel = "sudo=enabled";
+  }
   const lines = [];
-  lines.push(`${config.profiles.size} SSH host profile(s) from ${config.sourceLabel}:`);
-  for (const profile of config.profiles.values()) {
-    const summary = toHostSummary(profile);
-    let accessLabel = "writable";
-    if (summary.readonly == true) {
-      accessLabel = "READ-ONLY";
-    }
-    let sudoLabel = "sudo=disabled";
-    if (summary.allowSudo == true) {
-      sudoLabel = "sudo=enabled";
-    }
-    lines.push("");
-    lines.push(`${summary.name}  \u2192  ${summary.username}@${summary.host}:${summary.port}  auth=${summary.authMethod}  ${accessLabel}  ${sudoLabel}`);
-    if (summary.description != null) {
-      lines.push(`    ${summary.description}`);
-    }
-    if (summary.allowedPaths.length > 0) {
-      lines.push(`    file tools limited to: ${summary.allowedPaths.join(", ")} (does not restrict ssh_exec)`);
-    }
-    if (summary.allowCommands.length > 0) {
-      lines.push(`    commands limited to: ${summary.allowCommands.join(", ")}`);
-    }
+  lines.push(`${summary.name}  \u2192  ${summary.username}@${summary.host}:${summary.port}  auth=${summary.authMethod}  ${accessLabel}  ${sudoLabel}`);
+  if (summary.description != null) {
+    lines.push(`    ${summary.description}`);
+  }
+  if (summary.allowedPaths.length > 0) {
+    lines.push(`    file tools limited to: ${summary.allowedPaths.join(", ")} (does not restrict ssh_exec)`);
+  }
+  if (summary.allowCommands.length > 0) {
+    lines.push(`    commands limited to: ${summary.allowCommands.join(", ")}`);
   }
   return lines.join("\n");
 }
@@ -2438,40 +2252,16 @@ function toToolError(error, toolName, action) {
   _logger.error(error, `${toolName} failed`);
   return errorResult(`${toolName} failed: ${describeError(error)}`);
 }
-function requireProfile(context, target) {
-  const profile = context.config.profiles.get(target);
-  if (profile != null) {
-    return profile;
-  }
-  const available = Array.from(context.config.profiles.keys());
-  if (available.length === 0) {
-    throw new Error(`no host profiles are registered \u2014 set ${SINGLE_HOST_ENV.HOST} / ${SINGLE_HOST_ENV.USER} in this server's env block (or ${CONFIG_PATH_ENV} for several hosts), then restart it`);
-  }
-  throw new Error(`unknown host profile '${target}' (registered: ${available.join(", ")})`);
-}
 function resolveProfile(context, args) {
-  const hasTarget = args.target != null && args.target.trim() !== "";
   const hasSession = args.session != null && args.session.trim() !== "";
-  if (hasTarget == true && hasSession == true) {
-    throw new Error("pass either 'target' or 'session', not both \u2014 they can name different hosts with different policies");
-  }
   if (hasSession == true) {
     const session = context.sessions.require(args.session.trim());
     return { profile: session.profile, session };
   }
-  if (hasTarget == true) {
-    const profile = requireProfile(context, args.target.trim());
-    return { profile, session: null };
-  }
-  const onlyProfile = context.config.profiles.values().next().value;
-  if (context.config.profiles.size === 1 && onlyProfile != null) {
-    return { profile: onlyProfile, session: null };
+  if (context.profile == null) {
+    throw new Error(`no host is registered \u2014 set ${SINGLE_HOST_ENV.HOST} / ${SINGLE_HOST_ENV.USER} in this server's env block, then restart it`);
   }
-  if (context.config.profiles.size === 0) {
-    throw new Error(`no host profiles are registered \u2014 set ${SINGLE_HOST_ENV.HOST} / ${SINGLE_HOST_ENV.USER} in this server's env block, then restart it`);
-  }
-  const available = Array.from(context.config.profiles.keys());
-  throw new Error(`this server fronts several hosts, so 'target' is required (registered: ${available.join(", ")})`);
+  return { profile: context.profile, session: null };
 }
 async function withHostConnection(profile, session, operation) {
   if (session != null) {
@@ -2492,12 +2282,6 @@ async function withHostConnection(profile, session, operation) {
     }
   }
 }
-function protectedLocalPathsOf(context) {
-  if (context.config.sourcePath == null) {
-    return [];
-  }
-  return [context.config.sourcePath];
-}
 
 // src/modules/tools/exec-tools.ts
 function registerExecTools(server, context) {
@@ -2506,14 +2290,13 @@ function registerExecTools(server, context) {
     {
       title: "Run a command over SSH",
       description: [
-        "Run a shell command on a registered SSH host and return stdout, stderr and the exit code.",
-        "With a single configured host, no target is needed. Pass 'session' to reuse an open session (which remembers its working directory), or 'target' to pick a host when several are registered \u2014 one or the other, never both.",
+        "Run a shell command on the configured SSH host and return stdout, stderr and the exit code.",
+        "Pass 'session' to reuse an open session, which remembers its working directory; omit it and a one-off connection is opened and closed around the call.",
         "A non-zero exit code is reported as normal output, not as a tool error \u2014 read the exit code and stderr to judge the outcome.",
-        "Almost everything is permitted: package installs, service restarts, sudo, interpreters. Only catastrophic operations are refused outright (wiping the filesystem root, formatting a disk, rebooting, flushing the firewall), and individual profiles may add their own limits."
+        "Almost everything is permitted: package installs, service restarts, sudo, interpreters. Only catastrophic operations are refused outright (wiping the filesystem root, formatting a disk, rebooting, flushing the firewall), and the host may add its own limits."
       ].join(" "),
       inputSchema: {
         command: z.string().min(1).describe("Shell command, exactly as it would be typed in a terminal. Chaining with ';', '&&', '||' and pipes is allowed; each part is screened separately."),
-        target: z.string().optional().describe("Host profile alias. Omit it when this server fronts a single host, which is the usual setup. Opens a one-off connection that is closed afterwards."),
         session: z.string().optional().describe("Session id from ssh_connect. Reuses that connection and keeps the working directory across calls."),
         cwd: z.string().optional().describe("Absolute directory to run in, with no shell metacharacters. With a session, the session also moves there."),
         timeoutMs: z.number().int().positive().optional().describe("Lowers the command timeout for this call; it cannot exceed the profile's own limit. The channel is closed when it elapses; the remote process may survive.")
@@ -2525,10 +2308,10 @@ function registerExecTools(server, context) {
         openWorldHint: true
       }
     },
-    async ({ command, target, session, cwd, timeoutMs }) => {
+    async ({ command, session, cwd, timeoutMs }) => {
       let _logger = $logger.child({ context: "ssh_exec" });
       try {
-        const { profile, session: openSession } = resolveProfile(context, { target, session });
+        const { profile, session: openSession } = resolveProfile(context, { session });
         _logger = _logger.child({ profile: profile.name, session_id: openSession?.sessionId });
         const requestedTimeoutMs = timeoutMs ?? profile.policy.execTimeoutMs;
         const effectiveTimeoutMs = Math.min(requestedTimeoutMs, profile.policy.execTimeoutMs);
@@ -2564,10 +2347,9 @@ function registerExecTools(server, context) {
     }
   );
 }
-var TARGET_DESCRIPTION = "Host profile alias. Omit it when this server fronts a single host, which is the usual setup.";
-var SESSION_DESCRIPTION = "Session id from ssh_connect, whose connection is reused. Pass this or 'target', not both.";
-function requirePermittedLocalPath(context, localPath, access) {
-  const verdict = inspectLocalPath(localPath, access, protectedLocalPathsOf(context));
+var SESSION_DESCRIPTION = "Session id from ssh_connect, whose connection is reused. Omit it to open a one-off connection.";
+function requirePermittedLocalPath(localPath, access) {
+  const verdict = inspectLocalPath(localPath, access);
   if (verdict.allowed == false) {
     throw new GuardRejectionError(verdict);
   }
@@ -2578,12 +2360,11 @@ function registerFileTools(server, context) {
     {
       title: "List a remote directory",
       description: [
-        "List a directory on a registered SSH host over SFTP, with type, permissions, size and mtime.",
-        "Cheaper and more structured than running 'ls -la' through ssh_exec, and it works on read-only profiles."
+        "List a directory on the configured SSH host over SFTP, with type, permissions, size and mtime.",
+        "Cheaper and more structured than running 'ls -la' through ssh_exec, and it works on a read-only host."
       ].join(" "),
       inputSchema: {
-        path: z.string().min(1).describe("Absolute remote directory path. Profiles with allowedPaths set accept only paths inside them."),
-        target: z.string().optional().describe(TARGET_DESCRIPTION),
+        path: z.string().min(1).describe("Absolute remote directory path. When SSH_ALLOWED_PATHS is set, only paths inside it are accepted."),
         session: z.string().optional().describe(SESSION_DESCRIPTION)
       },
       annotations: {
@@ -2593,10 +2374,10 @@ function registerFileTools(server, context) {
         openWorldHint: true
       }
     },
-    async ({ path: remotePath, target, session }) => {
+    async ({ path: remotePath, session }) => {
       const _logger = $logger.child({ context: "ssh_list_dir", remote_path: remotePath });
       try {
-        const { profile, session: openSession } = resolveProfile(context, { target, session });
+        const { profile, session: openSession } = resolveProfile(context, { session });
         const listing = await withHostConnection(profile, openSession, async (connection) => {
           return await listRemoteDirectory(connection, remotePath);
         });
@@ -2623,9 +2404,8 @@ function registerFileTools(server, context) {
       ].join(" "),
       inputSchema: {
         path: z.string().min(1).describe("Absolute remote file path."),
-        target: z.string().optional().describe(TARGET_DESCRIPTION),
         session: z.string().optional().describe(SESSION_DESCRIPTION),
-        maxBytes: z.number().int().positive().optional().describe("Lowers the read ceiling for this call; it cannot exceed the profile's maxReadFileBytes.")
+        maxBytes: z.number().int().positive().optional().describe("Lowers the read ceiling for this call; it cannot exceed SSH_MAX_READ_BYTES.")
       },
       annotations: {
         readOnlyHint: true,
@@ -2634,10 +2414,10 @@ function registerFileTools(server, context) {
         openWorldHint: true
       }
     },
-    async ({ path: remotePath, target, session, maxBytes }) => {
+    async ({ path: remotePath, session, maxBytes }) => {
       const _logger = $logger.child({ context: "ssh_read_file", remote_path: remotePath });
       try {
-        const { profile, session: openSession } = resolveProfile(context, { target, session });
+        const { profile, session: openSession } = resolveProfile(context, { session });
         const requestedLimit = maxBytes ?? profile.policy.maxReadFileBytes;
         const readLimit = Math.min(requestedLimit, profile.policy.maxReadFileBytes);
         const file = await withHostConnection(profile, openSession, async (connection) => {
@@ -2669,14 +2449,13 @@ ${file.content}`);
     {
       title: "Write a remote file",
       description: [
-        "Write or append UTF-8 text to a file on a registered SSH host over SFTP.",
+        "Write or append UTF-8 text to a file on the configured SSH host over SFTP.",
         "Use this instead of 'echo ... > file' through ssh_exec: no shell quoting to get wrong, and it works with multi-line content.",
-        "Refused on read-only profiles. The parent directory must already exist."
+        "Refused on a read-only host. The parent directory must already exist."
       ].join(" "),
       inputSchema: {
         path: z.string().min(1).describe("Absolute remote file path. Existing content is replaced unless 'append' is true."),
         content: z.string().describe("UTF-8 text to write."),
-        target: z.string().optional().describe(TARGET_DESCRIPTION),
         session: z.string().optional().describe(SESSION_DESCRIPTION),
         append: z.boolean().optional().describe("Append instead of replacing. Defaults to false.")
       },
@@ -2687,10 +2466,10 @@ ${file.content}`);
         openWorldHint: true
       }
     },
-    async ({ path: remotePath, content, target, session, append }) => {
+    async ({ path: remotePath, content, session, append }) => {
       const _logger = $logger.child({ context: "ssh_write_file", remote_path: remotePath });
       try {
-        const { profile, session: openSession } = resolveProfile(context, { target, session });
+        const { profile, session: openSession } = resolveProfile(context, { session });
         const shouldAppend = append ?? false;
         const writtenBytes = await withHostConnection(profile, openSession, async (connection) => {
           return await writeRemoteFile(connection, {
@@ -2715,14 +2494,13 @@ ${file.content}`);
     {
       title: "Upload a file over SFTP",
       description: [
-        "Upload a local file to a registered SSH host over SFTP.",
-        "Refused on read-only profiles, and for local paths holding credentials (SSH keys, cloud credentials, this server's own config).",
+        "Upload a local file to the configured SSH host over SFTP.",
+        "Refused on a read-only host, and for local paths holding credentials (SSH keys, cloud credentials).",
         "The remote parent directory must already exist."
       ].join(" "),
       inputSchema: {
         localPath: z.string().min(1).describe("Local file path on the machine running this MCP server. '~' is expanded."),
         remotePath: z.string().min(1).describe("Absolute destination path on the remote host, including the filename."),
-        target: z.string().optional().describe(TARGET_DESCRIPTION),
         session: z.string().optional().describe(SESSION_DESCRIPTION)
       },
       annotations: {
@@ -2732,13 +2510,13 @@ ${file.content}`);
         openWorldHint: true
       }
     },
-    async ({ localPath, remotePath, target, session }) => {
+    async ({ localPath, remotePath, session }) => {
       const _logger = $logger.child({ context: "ssh_upload", remote_path: remotePath });
       try {
-        const { profile, session: openSession } = resolveProfile(context, { target, session });
+        const { profile, session: openSession } = resolveProfile(context, { session });
         const resolvedLocalPath = expandHomePath(localPath);
-        requirePermittedLocalPath(context, resolvedLocalPath, "read");
-        if (fs.existsSync(resolvedLocalPath) == false) {
+        requirePermittedLocalPath(resolvedLocalPath, "read");
+        if (fs2.existsSync(resolvedLocalPath) == false) {
           return textResult(`local file not found: ${resolvedLocalPath}`);
         }
         const transferredBytes = await withHostConnection(profile, openSession, async (connection) => {
@@ -2756,14 +2534,13 @@ ${file.content}`);
     {
       title: "Download a file over SFTP",
       description: [
-        "Download a file from a registered SSH host to the machine running this MCP server.",
+        "Download a file from the configured SSH host to the machine running this MCP server.",
         "Use this for binaries or files too large to read into the conversation; missing local directories are created.",
-        "The local destination is overwritten, and paths holding credentials or this server's own configuration are refused."
+        "The local destination is overwritten, and paths holding credentials are refused."
       ].join(" "),
       inputSchema: {
         remotePath: z.string().min(1).describe("Absolute source path on the remote host."),
         localPath: z.string().min(1).describe("Local destination path, including the filename. '~' is expanded. Overwritten if it exists."),
-        target: z.string().optional().describe(TARGET_DESCRIPTION),
         session: z.string().optional().describe(SESSION_DESCRIPTION)
       },
       annotations: {
@@ -2773,13 +2550,13 @@ ${file.content}`);
         openWorldHint: true
       }
     },
-    async ({ remotePath, localPath, target, session }) => {
+    async ({ remotePath, localPath, session }) => {
       const _logger = $logger.child({ context: "ssh_download", remote_path: remotePath });
       try {
-        const { profile, session: openSession } = resolveProfile(context, { target, session });
+        const { profile, session: openSession } = resolveProfile(context, { session });
         const resolvedLocalPath = expandHomePath(localPath);
-        requirePermittedLocalPath(context, resolvedLocalPath, "write");
-        fs.mkdirSync(path3.dirname(resolvedLocalPath), { recursive: true });
+        requirePermittedLocalPath(resolvedLocalPath, "write");
+        fs2.mkdirSync(path2.dirname(resolvedLocalPath), { recursive: true });
         const transferredBytes = await withHostConnection(profile, openSession, async (connection) => {
           return await downloadFile(connection, remotePath, resolvedLocalPath);
         });
@@ -2797,11 +2574,11 @@ function registerHostTools(server, context) {
   server.registerTool(
     "ssh_list_hosts",
     {
-      title: "List SSH host profiles",
+      title: "Show the SSH host",
       description: [
-        "List the SSH hosts this server may connect to, with each host's guard policy.",
-        "Call this first: every other tool takes a profile alias as its 'target', and no host outside this list can be reached.",
-        "Credentials are never returned \u2014 only which auth method the profile uses."
+        "Show the SSH host this server connects to, with its guard policy.",
+        "Call this first: it is the only reachable host, and its policy decides what the other tools will accept.",
+        "Credentials are never returned \u2014 only which auth method the host uses."
       ].join(" "),
       inputSchema: {},
       annotations: {
@@ -2814,59 +2591,11 @@ function registerHostTools(server, context) {
     async () => {
       const _logger = $logger.child({ context: "ssh_list_hosts" });
       try {
-        const listing = formatHostList(context.config);
-        _logger.debug("host list returned", { profile_count: context.config.profiles.size });
+        const listing = formatHostProfile(context.profile);
+        _logger.debug("host profile returned", { profile: context.profile?.name });
         return textResult(listing);
       } catch (ex) {
-        return toToolError(ex, "ssh_list_hosts", "list hosts");
-      }
-    }
-  );
-  server.registerTool(
-    "ssh_reload_config",
-    {
-      title: "Reload the host configuration",
-      description: [
-        "Re-read the host configuration and apply it, without restarting the MCP server.",
-        "Use after the operator edits the config file \u2014 adding a host, tightening a policy.",
-        "Every open session is closed first, so the new policy is in force everywhere rather than leaving old sessions on the old rules.",
-        "Configuration supplied through environment variables is fixed for the life of the process; changing that still needs a restart."
-      ].join(" "),
-      inputSchema: {},
-      annotations: {
-        readOnlyHint: false,
-        destructiveHint: false,
-        idempotentHint: true,
-        openWorldHint: false
-      }
-    },
-    async () => {
-      const _logger = $logger.child({ context: "ssh_reload_config" });
-      try {
-        const previousLabel = context.config.sourceLabel;
-        const closedSessions = context.sessions.list().length;
-        context.sessions.closeAll();
-        const reloaded = context.reloadConfig();
-        const lines = [
-          `Reloaded ${reloaded.profiles.size} host profile(s) from ${reloaded.sourceLabel}.`
-        ];
-        if (reloaded.profiles.size > 0) {
-          lines.push(`Hosts: ${Array.from(reloaded.profiles.keys()).join(", ")}`);
-        }
-        if (closedSessions > 0) {
-          lines.push(`Closed ${closedSessions} open session(s); reopen with ssh_connect if needed.`);
-        }
-        if (reloaded.sourcePath == null) {
-          lines.push("This config comes from environment variables, which cannot change while the server runs \u2014 restart the MCP server to apply edits to them.");
-        }
-        _logger.info("config reloaded", {
-          profile_count: reloaded.profiles.size,
-          previous_source: previousLabel,
-          config_source: reloaded.sourceLabel
-        });
-        return textResult(lines.join("\n"));
-      } catch (ex) {
-        return toToolError(ex, "ssh_reload_config", "reload the configuration");
+        return toToolError(ex, "ssh_list_hosts", "show the host");
       }
     }
   );
@@ -2877,13 +2606,12 @@ function registerSessionTools(server, context) {
     {
       title: "Open an SSH session",
       description: [
-        "Open a reusable SSH session to a registered host and return its session id.",
-        "Prefer this over one-off 'target' calls when running several commands: it pays the handshake once and remembers the working directory, so a 'cd' in one ssh_exec still applies to the next.",
+        "Open a reusable SSH session to the configured host and return its session id.",
+        "Prefer this over one-off calls when running several commands: it pays the handshake once and remembers the working directory, so a 'cd' in one ssh_exec still applies to the next.",
         "Close it with ssh_disconnect when done; idle sessions are reaped automatically, and a session whose connection drops reports that rather than silently reconnecting."
       ].join(" "),
       inputSchema: {
-        target: z.string().optional().describe("Host profile alias. Omit it when this server fronts a single host, which is the usual setup."),
-        cwd: z.string().optional().describe("Absolute directory to start in, with no shell metacharacters. Defaults to the profile's defaultCwd, else the login shell's directory.")
+        cwd: z.string().optional().describe("Absolute directory to start in, with no shell metacharacters. Defaults to SSH_CWD, else the login shell's directory.")
       },
       annotations: {
         readOnlyHint: false,
@@ -2892,11 +2620,11 @@ function registerSessionTools(server, context) {
         openWorldHint: true
       }
     },
-    async ({ target, cwd }) => {
-      let _logger = $logger.child({ context: "ssh_connect", target });
+    async ({ cwd }) => {
+      let _logger = $logger.child({ context: "ssh_connect" });
       let openedSessionId = null;
       try {
-        const { profile } = resolveProfile(context, { target });
+        const { profile } = resolveProfile(context, {});
         const session = await context.sessions.open(profile);
         openedSessionId = session.sessionId;
         _logger = _logger.child({ session_id: session.sessionId });
@@ -2921,7 +2649,7 @@ ${probe.stderr.trim()}`);
           `cwd: ${session.cwd}`
         ];
         if (profile.policy.readonly == true) {
-          lines.push("This profile is READ-ONLY: writes, redirections and uploads will be rejected.");
+          lines.push("This host is READ-ONLY: writes, redirections and uploads will be rejected.");
         }
         lines.push(`Run commands with ssh_exec({ session: "${session.sessionId}", command: "..." }).`);
         _logger.info("session opened via tool", { cwd: session.cwd });
@@ -2930,7 +2658,7 @@ ${probe.stderr.trim()}`);
         if (openedSessionId != null) {
           context.sessions.close(openedSessionId);
         }
-        return toToolError(ex, "ssh_connect", `connect to ${target ?? "the configured host"}`);
+        return toToolError(ex, "ssh_connect", "connect to the configured host");
       }
     }
   );
@@ -2998,31 +2726,30 @@ function registerAllTools(server, context) {
 
 // src/server.ts
 var SERVER_INSTRUCTIONS = [
-  "This server runs shell commands and transfers files on remote hosts over SSH.",
-  "Only hosts pre-registered in a local config file are reachable \u2014 arbitrary host/credential arguments are not accepted.",
+  "This server runs shell commands and transfers files on one remote host over SSH.",
+  "The host is fixed in this server's own environment \u2014 there is no host argument, and no other machine is reachable through it.",
   "",
-  "Usually one server entry fronts one host, so no 'target' argument is needed \u2014 omit it and the configured host is used. ssh_list_hosts shows what is registered and what it permits.",
+  "ssh_list_hosts shows which host this is and what it permits. Call it before assuming anything about access.",
   "",
   "Workflow:",
   "1. One command: ssh_exec with just 'command'.",
   "2. Several commands in a row: ssh_connect once, then ssh_exec with 'session' (the working directory persists across calls), then ssh_disconnect.",
   "3. Files: ssh_list_dir, ssh_read_file, ssh_write_file, ssh_upload, ssh_download \u2014 prefer these over shell equivalents; no quoting to get wrong.",
-  "Pass 'target' only when ssh_list_hosts shows several hosts, and never together with 'session'.",
   "",
   "What is permitted: ordinary administration, without asking \u2014 package installs, service restarts, sudo, interpreters, config edits, deployments.",
-  "Refused on every profile, and only these: operations that destroy the machine or cut this connection \u2014 wiping the filesystem root or a system directory, deleting a file the host cannot boot without, formatting a disk, writing raw bytes to a block device, rebooting or powering off, flushing the firewall, removing every cron job.",
-  "Individual profiles may add their own limits (read-only, an allow-list, deny patterns, path restrictions). ssh_list_hosts shows which apply where.",
+  "Refused always, and only these: operations that destroy the machine or cut this connection \u2014 wiping the filesystem root or a system directory, deleting a file the host cannot boot without, formatting a disk, writing raw bytes to a block device, rebooting or powering off, flushing the firewall, removing every cron job.",
+  "The host may add its own limits (read-only, an allow-list, deny patterns, path restrictions). ssh_list_hosts shows which apply.",
   "",
   "Commands run with no terminal and with stdin closed, so anything that waits for input fails immediately instead of hanging: use non-interactive flags (apt-get -y, sudo -n), 'top -bn1' rather than 'top', and ssh_write_file rather than an editor.",
   "A job that may outlive its timeout should be started detached (nohup \u2026 &, tmux new -d) and polled through its log.",
   "",
   "A guard rejection is a policy decision, not a transient failure \u2014 do not retry the same command; report it and ask before working around it.",
   "A non-zero exit code is returned as normal output; read it and stderr to judge what happened.",
-  "You still carry the judgement the guards do not: these are real hosts, and an irreversible action deserves a check with the operator first."
+  "You still carry the judgement the guards do not: this is a real host, and an irreversible action deserves a check with the operator first."
 ].join("\n");
-function createSshMcpServer(options) {
+function createSshMcpServer() {
   const _logger = $logger.child({ context: "createSshMcpServer" });
-  const config = loadConfig(options?.configPath);
+  const profile = loadHostProfile();
   const sessions = new SshSessionManager();
   sessions.startIdleSweeper();
   const server = new McpServer(
@@ -3035,28 +2762,15 @@ function createSshMcpServer(options) {
     }
   );
   const context = {
-    config,
-    sessions,
-    reloadConfig() {
-      const reloaded = loadConfig(options?.configPath);
-      context.config = reloaded;
-      return reloaded;
-    }
+    profile,
+    sessions
   };
   registerAllTools(server, context);
-  _logger.info("mcp server built", {
-    profile_count: config.profiles.size,
-    config_source: config.sourceLabel
-  });
+  _logger.info("mcp server built", { profile: profile?.name ?? null });
   return {
     server,
     sessions,
-    get config() {
-      return context.config;
-    },
-    reloadConfig() {
-      return context.reloadConfig();
-    },
+    profile,
     shutdown() {
       sessions.stopIdleSweeper();
       sessions.closeAll();
@@ -3064,6 +2778,6 @@ function createSshMcpServer(options) {
   };
 }
 
-export { $logger, CONFIG_INPUT_SCHEMA, CONFIG_PATH_ENV, GuardRejectionError, HOST_INPUT_SCHEMA, LOG_LEVEL_ENV, POLICY_INPUT_SCHEMA, SERVER_NAME, SERVER_VERSION, SshConnection, SshSession, SshSessionManager, analyzeSegment, canonicalizeCommand, createSshMcpServer, downloadFile, extractSubstitutions, inspectCommand, inspectLocalPath, inspectRemotePath, inspectWorkingDirectory, listRemoteDirectory, loadConfig, normalizeCommandText, readRemoteFile, registerAllTools, splitCommandSegments, stripQuotedText, toHostSummary, uploadFile, writeRemoteFile };
+export { $logger, GuardRejectionError, LOG_LEVEL_ENV, SERVER_NAME, SERVER_VERSION, SINGLE_HOST_ENV, SshConnection, SshSession, SshSessionManager, analyzeSegment, canonicalizeCommand, createSshMcpServer, downloadFile, extractSubstitutions, inspectCommand, inspectLocalPath, inspectRemotePath, inspectWorkingDirectory, listRemoteDirectory, loadHostProfile, normalizeCommandText, readRemoteFile, registerAllTools, splitCommandSegments, stripQuotedText, toHostSummary, uploadFile, writeRemoteFile };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map