How to use ssh-config - 10 common examples

function parseSshConfig(sshConfigFileContents) {
    // Previously we were using a library that parsed ssh config files into arrays.
    // Mimic that behavior here so the rest of the code doesn't need to change.
    return objectToArray(sshConfig.parse(sshConfigFileContents));
}

const loadFromLocal = () => {
    const managedConfig = readManagedLocalConfig()
    const config = sshConfig.parse(managedConfig)

    // Return an empty array in case the local file is empty.
    if (!0 in config) return []

    // Extract items.
    const items = Object.keys(config)
      .filter((key) => {
        const index = Number(key)
        return Number.isInteger(index)
      })
      .map((key) => config[key])
      .map((item) => convertToAppFormat(item))

    return items
  }

const update = (items) => {

    const newConfig = sshConfig.parse('')
    // Convert items to the config format and append to the new config.
    items.forEach((item) => {
      const convertedItem = convertToConfigFormat(item)
      newConfig.append(convertedItem)
    })

    const newConfigString = sshConfig.stringify(newConfig);

    const unmanagedConfig = readUnmanagedLocalConfig()

    return unmanagedConfig
      .trim()
      .concat("\n", settings.startTag)
      .concat("\n", newConfigString)
      .concat("\n", settings.endTag)
  }

fs.readFile(process.env.HOME + '/.ssh/config', function (err, data) {
  if (err) {
    throw err;
  }

  sshConfig = sshConfig.parse(data.toString());

  var output = {
    Profiles: [],
  };

  for (var i = 0, len = sshConfig.length; i < len; i++) {
    var section = sshConfig[i];

    var host = section.Host;

    var comment = null;
    var commentIndex = section.Host.indexOf('#');

    if (commentIndex !== -1) {
      host = section.Host.substr(0, commentIndex);
      comment = section.Host.substr(commentIndex + 1).trim();
    }
    var host = host.trim();

    // Skip Wildcard Entries
    if (host.indexOf('*') != -1) continue;

it('should stringify with config5 file', async () => {
        const config5 = await readFile(path.resolve(__dirname, 'fixtures/ssh-config/config5'), { encoding: 'utf8' });
        const conf = SSHConfig.parse(config5);
        ensureHostAndKeyPath(conf, { host: 'bar' }, '/id_rsa');
        expect(SSHConfig.stringify(conf)).toEqual(config5);
      });

it('should stringify with config3 file', async () => {
        const config3 = await readFile(path.resolve(__dirname, 'fixtures/ssh-config/config3'), { encoding: 'utf8' });
        const conf = SSHConfig.parse(config3);
        ensureHostAndKeyPath(conf, { host: 'bar' }, '/id_rsa');
        expect(SSHConfig.stringify(conf)).toEqual(config3);
      });

export function resolverFromConfig(text: string): ConfigResolver {
	const config = parseConfig(text);
	return h => config.compute(h.Host);
}

ensureSection(conf: SSHConfig.SSHConfig, host: string, newline: boolean): SSHConfig.ConfigDirective {
    const section = conf.find({ Host: host });

    if (!section) {
      conf.push(SSHConfig.parse(`${newline ? '\n' : ''}Host ${host}\n`)[0]);
    }

    return conf.find({ Host: host });
  }

async applyConfig(text: string, keyPath: string): Promise {
    const c = await this.config.load();
    const conf = SSHConfig.parse(text);
    const host = c.git.host;
    const section = this.ensureSection(conf, host, Boolean(text));

    this.ensureSectionLine(section, 'IdentityFile', keyPath);

    if (typeof c.git.port === 'number') {
      this.ensureSectionLine(section, 'Port', String(c.git.port));
    }

    return SSHConfig.stringify(conf);
  }

export async function loadFromPath(p: string): Promise {
  const s = await fileToString(p);

  return SSHConfig.parse(s);
}