@akms/mcp-ssh 0.0.1 → 0.0.2

package/lib/cli.cjs

@@ -5,7 +5,7 @@ var stdio_js = require('@modelcontextprotocol/sdk/server/stdio.js');
 var os = require('os');
 var path2 = require('path');
 var crypto = require('crypto');
-var fs4 = require('fs');
+var fs = require('fs');
 var string_decoder = require('string_decoder');
 var ssh2 = require('ssh2');
 var timers = require('timers');
@@ -16,16 +16,11 @@ function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
 var os__default = /*#__PURE__*/_interopDefault(os);
 var path2__default = /*#__PURE__*/_interopDefault(path2);
-var fs4__default = /*#__PURE__*/_interopDefault(fs4);
+var fs__default = /*#__PURE__*/_interopDefault(fs);
 var ssh2__default = /*#__PURE__*/_interopDefault(ssh2);
 
 // 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;
@@ -36,8 +31,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(
@@ -420,10 +415,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"
@@ -448,7 +439,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",
@@ -1052,14 +1043,14 @@ function inspectRemotePath(remotePath, policy, access) {
 function toRealPath(inputPath) {
   const _logger = $logger.child({ context: "toRealPath" });
   try {
-    return fs4__default.default.realpathSync.native(inputPath);
+    return fs__default.default.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 = fs4__default.default.realpathSync.native(path2__default.default.dirname(inputPath));
+    const parentRealPath = fs__default.default.realpathSync.native(path2__default.default.dirname(inputPath));
     return path2__default.default.join(parentRealPath, path2__default.default.basename(inputPath));
   } catch (ex) {
     _logger.debug("parent directory does not resolve either, comparing lexically", {
@@ -1151,7 +1142,7 @@ function readPrivateKey(profile, keyPath) {
     return cached;
   }
   try {
-    const contents = fs4__default.default.readFileSync(keyPath);
+    const contents = fs__default.default.readFileSync(keyPath);
     PRIVATE_KEY_CACHE.set(keyPath, contents);
     return contents;
   } catch (ex) {
@@ -1197,8 +1188,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;
@@ -1215,7 +1204,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) {
@@ -1928,7 +1917,7 @@ async function writeRemoteFile(connection, args) {
 }
 async function uploadFile(connection, localPath, remotePath) {
   requirePermittedPath(connection, remotePath, "write");
-  const localStats = fs4__default.default.statSync(localPath);
+  const localStats = fs__default.default.statSync(localPath);
   if (localStats.isFile() == false) {
     throw new Error(`local path is not a file: ${localPath}`);
   }
@@ -1965,7 +1954,7 @@ async function downloadFile(connection, remotePath, localPath) {
       });
     });
   });
-  const localStats = fs4__default.default.statSync(localPath);
+  const localStats = fs__default.default.statSync(localPath);
   const _logger = $logger.child({
     context: "downloadFile",
     profile: connection.profile.name,
@@ -1975,43 +1964,6 @@ async function downloadFile(connection, remotePath, localPath) {
   _logger.info("file downloaded", { bytes: localStats.size });
   return localStats.size;
 }
-var POLICY_INPUT_SCHEMA = zod.z.strictObject({
-  readonly: zod.z.boolean().optional(),
-  allowSudo: zod.z.boolean().optional(),
-  execTimeoutMs: zod.z.number().int().positive().optional(),
-  connectTimeoutMs: zod.z.number().int().positive().optional(),
-  maxOutputCharacters: zod.z.number().int().positive().optional(),
-  maxReadFileBytes: zod.z.number().int().positive().optional(),
-  allowCommands: zod.z.array(zod.z.string()).optional(),
-  denyPatterns: zod.z.array(zod.z.string()).optional(),
-  allowedPaths: zod.z.array(zod.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: zod.z.string().min(1),
-  port: zod.z.number().int().min(1).max(65535).optional(),
-  username: zod.z.string().min(1),
-  description: zod.z.string().optional(),
-  privateKeyPath: zod.z.string().optional(),
-  privateKey: zod.z.string().optional(),
-  passphrase: zod.z.string().optional(),
-  /** Name of an env var holding the passphrase, preferred over inlining it. */
-  passphraseEnv: zod.z.string().optional(),
-  password: zod.z.string().optional(),
-  /** Name of an env var holding the password, preferred over inlining it. */
-  passwordEnv: zod.z.string().optional(),
-  /** Pinned server host key, e.g. "SHA256:abc123…". */
-  hostKeyFingerprint: zod.z.string().optional(),
-  defaultCwd: zod.z.string().optional()
-});
-var CONFIG_INPUT_SCHEMA = zod.z.strictObject({
-  /** Ignored at runtime; present so editors can attach a JSON schema. */
-  $schema: zod.z.string().optional(),
-  defaults: POLICY_INPUT_SCHEMA.optional(),
-  hosts: zod.z.record(zod.z.string(), HOST_INPUT_SCHEMA)
-});
-
-// src/modules/config/env-host.ts
 function readEnv(name) {
   const value = process.env[name];
   if (value == null) {
@@ -2059,220 +2011,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 = path2__default.default.join(os__default.default.homedir(), filename);
-    if (fs4__default.default.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 (fs4__default.default.existsSync(expandedKeyPath) == false) {
-      const _logger = $logger.child({ context: "toHostProfile", profile: name });
-      _logger.warn("privateKeyPath does not exist; connections for this profile will fail", {
+    if (fs__default.default.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 = fs4__default.default.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 (fs4__default.default.existsSync(source.path) == false) {
-        _logger.error(null, "config file does not exist");
-        throw new Error(`ssh mcp config not found: ${source.path}`);
-      }
-      rawText = fs4__default.default.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";
@@ -2298,44 +2114,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");
 }
@@ -2447,40 +2261,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.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`);
+  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`);
   }
-  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) {
@@ -2501,12 +2291,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) {
@@ -2515,14 +2299,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: zod.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: zod.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: zod.z.string().optional().describe("Session id from ssh_connect. Reuses that connection and keeps the working directory across calls."),
         cwd: zod.z.string().optional().describe("Absolute directory to run in, with no shell metacharacters. With a session, the session also moves there."),
         timeoutMs: zod.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.")
@@ -2534,10 +2317,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);
@@ -2573,10 +2356,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);
   }
@@ -2587,12 +2369,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: zod.z.string().min(1).describe("Absolute remote directory path. Profiles with allowedPaths set accept only paths inside them."),
-        target: zod.z.string().optional().describe(TARGET_DESCRIPTION),
+        path: zod.z.string().min(1).describe("Absolute remote directory path. When SSH_ALLOWED_PATHS is set, only paths inside it are accepted."),
         session: zod.z.string().optional().describe(SESSION_DESCRIPTION)
       },
       annotations: {
@@ -2602,10 +2383,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);
         });
@@ -2632,9 +2413,8 @@ function registerFileTools(server, context) {
       ].join(" "),
       inputSchema: {
         path: zod.z.string().min(1).describe("Absolute remote file path."),
-        target: zod.z.string().optional().describe(TARGET_DESCRIPTION),
         session: zod.z.string().optional().describe(SESSION_DESCRIPTION),
-        maxBytes: zod.z.number().int().positive().optional().describe("Lowers the read ceiling for this call; it cannot exceed the profile's maxReadFileBytes.")
+        maxBytes: zod.z.number().int().positive().optional().describe("Lowers the read ceiling for this call; it cannot exceed SSH_MAX_READ_BYTES.")
       },
       annotations: {
         readOnlyHint: true,
@@ -2643,10 +2423,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) => {
@@ -2678,14 +2458,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: zod.z.string().min(1).describe("Absolute remote file path. Existing content is replaced unless 'append' is true."),
         content: zod.z.string().describe("UTF-8 text to write."),
-        target: zod.z.string().optional().describe(TARGET_DESCRIPTION),
         session: zod.z.string().optional().describe(SESSION_DESCRIPTION),
         append: zod.z.boolean().optional().describe("Append instead of replacing. Defaults to false.")
       },
@@ -2696,10 +2475,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, {
@@ -2724,14 +2503,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: zod.z.string().min(1).describe("Local file path on the machine running this MCP server. '~' is expanded."),
         remotePath: zod.z.string().min(1).describe("Absolute destination path on the remote host, including the filename."),
-        target: zod.z.string().optional().describe(TARGET_DESCRIPTION),
         session: zod.z.string().optional().describe(SESSION_DESCRIPTION)
       },
       annotations: {
@@ -2741,13 +2519,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 (fs4__default.default.existsSync(resolvedLocalPath) == false) {
+        requirePermittedLocalPath(resolvedLocalPath, "read");
+        if (fs__default.default.existsSync(resolvedLocalPath) == false) {
           return textResult(`local file not found: ${resolvedLocalPath}`);
         }
         const transferredBytes = await withHostConnection(profile, openSession, async (connection) => {
@@ -2765,14 +2543,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: zod.z.string().min(1).describe("Absolute source path on the remote host."),
         localPath: zod.z.string().min(1).describe("Local destination path, including the filename. '~' is expanded. Overwritten if it exists."),
-        target: zod.z.string().optional().describe(TARGET_DESCRIPTION),
         session: zod.z.string().optional().describe(SESSION_DESCRIPTION)
       },
       annotations: {
@@ -2782,13 +2559,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");
-        fs4__default.default.mkdirSync(path2__default.default.dirname(resolvedLocalPath), { recursive: true });
+        requirePermittedLocalPath(resolvedLocalPath, "write");
+        fs__default.default.mkdirSync(path2__default.default.dirname(resolvedLocalPath), { recursive: true });
         const transferredBytes = await withHostConnection(profile, openSession, async (connection) => {
           return await downloadFile(connection, remotePath, resolvedLocalPath);
         });
@@ -2806,11 +2583,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: {
@@ -2823,59 +2600,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");
       }
     }
   );
@@ -2886,13 +2615,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: zod.z.string().optional().describe("Host profile alias. Omit it when this server fronts a single host, which is the usual setup."),
-        cwd: zod.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: zod.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,
@@ -2901,11 +2629,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 });
@@ -2930,7 +2658,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 });
@@ -2939,7 +2667,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");
       }
     }
   );
@@ -3007,31 +2735,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 mcp_js.McpServer(
@@ -3044,28 +2771,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();
@@ -3076,8 +2790,7 @@ function createSshMcpServer(options) {
 // src/cli.ts
 function parseArguments(argv) {
   const parsed = { showHelp: false, showVersion: false, checkOnly: false };
-  for (let index = 0; index < argv.length; index++) {
-    const argument = argv[index];
+  for (const argument of argv) {
     if (argument === "--help" || argument === "-h") {
       parsed.showHelp = true;
       continue;
@@ -3090,23 +2803,6 @@ function parseArguments(argv) {
       parsed.checkOnly = true;
       continue;
     }
-    if (argument === "--config" || argument === "-c") {
-      const value = argv[index + 1];
-      if (value == null || value.startsWith("-") == true) {
-        throw new Error(`${argument} requires a file path`);
-      }
-      parsed.configPath = value;
-      index++;
-      continue;
-    }
-    if (argument.startsWith("--config=") == true) {
-      const value = argument.slice("--config=".length);
-      if (value === "") {
-        throw new Error("--config= requires a file path");
-      }
-      parsed.configPath = value;
-      continue;
-    }
   }
   return parsed;
 }
@@ -3114,20 +2810,32 @@ var HELP_TEXT = [
   `${SERVER_NAME} ${SERVER_VERSION} \u2014 MCP server for SSH command execution and SFTP transfers`,
   "",
   "Usage:",
-  "  akms-ssh [--config <path>]",
+  "  akms-mcp-ssh [--check]",
   "",
   "Options:",
-  "  -c, --config <path>  Host profile config file",
-  `                       (default: ${CONFIG_PATH_ENV} env var, else ~/${DEFAULT_CONFIG_FILENAMES[0]})`,
-  "      --check          Connect to every profile, report the result, and exit.",
-  "                       Prints each host key fingerprint so it can be pinned.",
+  "      --check          Connect to the configured host, report the result, and exit.",
+  "                       Prints the host key fingerprint so it can be pinned.",
   "  -v, --version        Print the version and exit",
   "  -h, --help           Print this help and exit",
   "",
-  "Environment:",
-  `  ${CONFIG_PATH_ENV}     Host profiles as JSON, or a path to a JSON file.`,
-  "                     A value starting with '{' is read as the config itself, so an",
-  "                     MCP client can carry the whole setup in its own env block.",
+  "Environment \u2014 one server entry per host, set in the MCP client's env block:",
+  `  ${SINGLE_HOST_ENV.HOST}          Hostname or IP  (required)`,
+  `  ${SINGLE_HOST_ENV.USER}          Login user      (required)`,
+  `  ${SINGLE_HOST_ENV.PORT}          Default 22`,
+  `  ${SINGLE_HOST_ENV.KEY}           Path to a private key file, '~' expanded`,
+  `  ${SINGLE_HOST_ENV.PASSPHRASE}    Key passphrase`,
+  `  ${SINGLE_HOST_ENV.PASSWORD}      Password auth, when no key is used`,
+  `  ${SINGLE_HOST_ENV.HOST_KEY}      Pinned host key, 'SHA256:\u2026'; a mismatch aborts the connection`,
+  `  ${SINGLE_HOST_ENV.NAME}          Alias shown to the model; defaults to the hostname`,
+  `  ${SINGLE_HOST_ENV.DESCRIPTION}   Shown to the model \u2014 say what the host is for`,
+  `  ${SINGLE_HOST_ENV.CWD}           Directory new sessions start in`,
+  `  ${SINGLE_HOST_ENV.READONLY}      Reject write commands, redirections, uploads  (default false)`,
+  `  ${SINGLE_HOST_ENV.ALLOW_SUDO}    Allow sudo / su / doas  (default true)`,
+  `  ${SINGLE_HOST_ENV.ALLOW_COMMANDS}  Comma-separated allow-list of binaries`,
+  `  ${SINGLE_HOST_ENV.DENY_PATTERNS}   Comma-separated extra deny regexes`,
+  `  ${SINGLE_HOST_ENV.ALLOWED_PATHS}   Comma-separated path prefixes the file tools may touch`,
+  `  ${SINGLE_HOST_ENV.EXEC_TIMEOUT_MS} / ${SINGLE_HOST_ENV.CONNECT_TIMEOUT_MS}`,
+  `  ${SINGLE_HOST_ENV.MAX_OUTPUT_CHARACTERS} / ${SINGLE_HOST_ENV.MAX_READ_FILE_BYTES}`,
   `  ${LOG_LEVEL_ENV}  silent | debug | info | warn | error  (default: info, written to stderr)`,
   "",
   "The server speaks MCP over stdio; run it from an MCP client, not interactively."
@@ -3136,79 +2844,56 @@ function describeAuth(profile) {
   if (profile.privateKeyPath != null) {
     return `key ${profile.privateKeyPath}`;
   }
-  if (profile.privateKey != null) {
-    return "inline key";
-  }
   if (profile.password != null) {
     return "password";
   }
   return "ssh agent";
 }
-async function runConnectionCheck(config) {
-  if (config.profiles.size === 0) {
-    process.stdout.write(`No host profiles are registered (config source: ${config.sourceLabel}).
+async function runConnectionCheck(profile) {
+  if (profile == null) {
+    process.stdout.write(`No SSH host is registered \u2014 set ${SINGLE_HOST_ENV.HOST} and ${SINGLE_HOST_ENV.USER}.
 `);
     return 1;
   }
-  process.stdout.write(`Checking ${config.profiles.size} profile(s) from ${config.sourceLabel}
+  const endpoint = `${profile.username}@${profile.host}:${profile.port}`;
+  const auth = describeAuth(profile);
+  process.stdout.write(`Checking ${profile.name}  \u2192  ${endpoint}
 
 `);
-  const profiles = Array.from(config.profiles.values());
-  const results = await Promise.all(profiles.map(async (profile) => {
-    const connection = new SshConnection(profile);
-    const startedAt = Date.now();
-    try {
-      await connection.connect();
-      return {
-        profile,
-        connected: true,
-        durationMs: Date.now() - startedAt,
-        fingerprint: connection.hostKeyFingerprint,
-        detail: ""
-      };
-    } catch (ex) {
-      let detail = String(ex);
-      if (ex instanceof Error) {
-        detail = ex.message;
-      }
-      return {
-        profile,
-        connected: false,
-        durationMs: Date.now() - startedAt,
-        fingerprint: connection.hostKeyFingerprint,
-        detail
-      };
-    } finally {
-      connection.disconnect();
+  const connection = new SshConnection(profile);
+  const startedAt = Date.now();
+  let connected = false;
+  let detail = "";
+  try {
+    await connection.connect();
+    connected = true;
+  } catch (ex) {
+    detail = String(ex);
+    if (ex instanceof Error) {
+      detail = ex.message;
     }
-  }));
-  let connectedCount = 0;
-  for (const result of results) {
-    const endpoint = `${result.profile.username}@${result.profile.host}:${result.profile.port}`;
-    const auth = describeAuth(result.profile);
-    if (result.connected == true) {
-      connectedCount += 1;
-      process.stdout.write(`  OK      ${result.profile.name}  \u2192  ${endpoint}  (${auth}, ${result.durationMs}ms)
+  } finally {
+    connection.disconnect();
+  }
+  const durationMs = Date.now() - startedAt;
+  if (connected == true) {
+    process.stdout.write(`  OK      ${endpoint}  (${auth}, ${durationMs}ms)
 `);
-    } else {
-      process.stdout.write(`  FAILED  ${result.profile.name}  \u2192  ${endpoint}  (${auth})
+  } else {
+    process.stdout.write(`  FAILED  ${endpoint}  (${auth})
 `);
-      process.stdout.write(`          ${result.detail}
+    process.stdout.write(`          ${detail}
 `);
+  }
+  if (connection.hostKeyFingerprint != null) {
+    let pinNote = `not pinned \u2014 set ${SINGLE_HOST_ENV.HOST_KEY} to it to detect a changed key`;
+    if (profile.hostKeyFingerprint != null) {
+      pinNote = "pinned";
     }
-    if (result.fingerprint != null) {
-      let pinNote = "not pinned \u2014 add it as hostKeyFingerprint to detect a changed key";
-      if (result.profile.hostKeyFingerprint != null) {
-        pinNote = "pinned";
-      }
-      process.stdout.write(`          host key ${result.fingerprint}  (${pinNote})
+    process.stdout.write(`          host key ${connection.hostKeyFingerprint}  (${pinNote})
 `);
-    }
   }
-  process.stdout.write(`
-${connectedCount} of ${results.length} reachable
-`);
-  if (connectedCount === results.length) {
+  if (connected == true) {
     return 0;
   }
   return 1;
@@ -3229,9 +2914,9 @@ async function main() {
   if (cliArguments.checkOnly == true && process.env[LOG_LEVEL_ENV] == null) {
     process.env[LOG_LEVEL_ENV] = "silent";
   }
-  const instance = createSshMcpServer({ configPath: cliArguments.configPath });
+  const instance = createSshMcpServer();
   if (cliArguments.checkOnly == true) {
-    const exitCode = await runConnectionCheck(instance.config);
+    const exitCode = await runConnectionCheck(instance.profile);
     instance.shutdown();
     process.exit(exitCode);
   }
@@ -3261,8 +2946,7 @@ async function main() {
   _logger.info("mcp server ready on stdio", {
     server: SERVER_NAME,
     version: SERVER_VERSION,
-    config_source: instance.config.sourceLabel,
-    profile_count: instance.config.profiles.size
+    profile: instance.profile?.name ?? null
   });
 }
 main().catch((error) => {
@@ -3272,7 +2956,7 @@ main().catch((error) => {
   if (error instanceof Error) {
     detail = error.message;
   }
-  process.stderr.write(`akms-ssh: ${detail}
+  process.stderr.write(`akms-mcp-ssh: ${detail}
 `);
   process.exit(1);
 });