function uninstall() {
  const system = systemsById[systemId];
  if (system == null) {
    console.error(`System ${systemId} is not installed.`);
    process.exit(1);
  }

  if (pluginFullName == null) {
    const r1 = readline.createInterface({ input: process.stdin, output: process.stdout });
    r1.question(`Are you sure you want to uninstall the system ${systemId} ? (yes/no): `, (answer) => {
      if (answer === "yes") uninstallSystem(system.folderName);
      else process.exit(0);
    });

  } else {
    const [ pluginAuthor, pluginName ] = pluginFullName.split("/");
    if (builtInPluginAuthors.indexOf(pluginAuthor) !== -1) {
      console.error(`Built-in plugins can not be uninstalled.`);
      process.exit(1);
    }

    if (system.plugins[pluginAuthor] == null || system.plugins[pluginAuthor].indexOf(pluginName) === -1) {
      console.error(`Plugin ${pluginFullName} is not installed.`);
      process.exit(1);
    }

    const r1 = readline.createInterface({ input: process.stdin, output: process.stdout });
    r1.question(`Are you sure you want to uninstall the plugin ${pluginFullName} ? (yes/no): `, (answer) => {
      if (answer === "yes") uninstallPlugin(system.folderName, pluginAuthor);
      else process.exit(0);
    });
  }
}

    runTask: (command: string, args: string[], config: TaskConfig) => {
      let loggerCategory = config.name;
      let logger = config.logger;

      logger.log(loggerCategory, `running command ${command} ${args.join(' ')}`);
      let task = spawn(command, args);

      let stdout = createInterface({ input: task.stdout });
      stdout.on('line', line => {
        line = strip(line);
        if (!line) {
          return;
        }
        let handled = false;
        if (config.handleOutput) {
          handled = config.handleOutput(line);
        }
        if (!handled) {
          logger.log(loggerCategory, line);
        }
      });

      let stderr = createInterface({ input: task.stderr });
      stderr.on('line', line => {
        line = strip(line);
        if (!line) {
          return;
        }
        let handled = false;
        if (config.handleError) {
          handled = config.handleError(line);
        }
        if (!handled) {
          logger.error(loggerCategory, line);
        }
      });

      let result = new Promise<void>((resolve, reject) => {
        task.on('close', (code: number) => {
          if (code === 0 || code === null) {
            resolve();
          } else {
            reject(`Process exited with code ${code}`);
          }
        });
      });

      return {
        result,
        kill: () => {
          kill(task.pid);
        }
      };
    }

export default function uninstall(systemId: string, pluginFullName: string) {
  const system = utils.systemsById[systemId];
  if (system == null) utils.emitError(`System ${systemId} is not installed.`);

  if (pluginFullName == null) {
    if (system.isDev) utils.emitError(`System ${systemId} is a development version.`);

    if (utils.force) {
      uninstallSystem(system.folderName);
      return;
    }

    const r1 = readline.createInterface({ input: process.stdin, output: process.stdout });
    r1.question(`Are you sure you want to uninstall the system ${systemId}? (yes/no): `, (answer) => {
      if (answer === "yes") {
        console.log(`Uninstalling system ${systemId}...`);
        uninstallSystem(system.folderName);
      } else {
        console.log(`Uninstall canceled.`);
        process.exit(0);
      }
    });

  } else {
    const [ pluginAuthor, pluginName ] = pluginFullName.split("/");
    if (utils.builtInPluginAuthors.indexOf(pluginAuthor) !== -1) utils.emitError(`Built-in plugins can not be uninstalled.`);

    if (system.plugins[pluginAuthor] == null || system.plugins[pluginAuthor].indexOf(pluginName) === -1)
      utils.emitError(`Plugin ${pluginFullName} is not installed.`);

    let isDevFolder = true;
    try { fs.readdirSync(`${utils.systemsPath}/${system.folderName}/plugins/${pluginFullName}/.git`); } catch (err) { isDevFolder = false; }
    if (isDevFolder) utils.emitError(`Plugin ${pluginFullName} is a development version.`);

    if (utils.force) {
      uninstallPlugin(system.folderName, pluginFullName, pluginAuthor);
      return;
    }

    const r1 = readline.createInterface({ input: process.stdin, output: process.stdout });
    r1.question(`Are you sure you want to uninstall the plugin ${pluginFullName}? (yes/no): `, (answer) => {
      if (answer === "yes") {
        console.log(`Uninstalling plugin ${pluginFullName} from system ${systemId}...`);
        uninstallPlugin(system.folderName, pluginFullName, pluginAuthor);
      } else {
        console.log(`Uninstall canceled.`);
        process.exit(0);
      }
    });
  }
}

export default function uninstall(systemId: string, pluginFullName: string) {
  const localSystem = utils.systemsById[systemId];
  if (localSystem == null) utils.emitError(`System ${systemId} is not installed.`);

  if (pluginFullName == null) {
    // Uninstall system
    if (localSystem.isDev) utils.emitError(`System ${systemId} is a development version.`);

    if (utils.force) {
      uninstallSystem(localSystem.folderName);
      return;
    }

    const r1 = readline.createInterface({ input: process.stdin, output: process.stdout });
    r1.question(`Are you sure you want to uninstall the system ${systemId}? (yes/no): `, (answer) => {
      if (answer === "yes") {
        console.log(`Uninstalling system ${systemId}...`);
        uninstallSystem(localSystem.folderName);
      } else {
        console.log(`Uninstall canceled.`);
        process.exit(0);
      }
    });

  } else {
    // Uninstall plugin
    const [ authorName, pluginName ] = pluginFullName.split("/");
    if (utils.builtInPluginAuthors.indexOf(authorName) !== -1) utils.emitError(`Built-in plugins can not be uninstalled.`);

    const localPlugin = localSystem.plugins[authorName] != null ? localSystem.plugins[authorName][pluginName] : null;
    if (localPlugin == null) utils.emitError(`Plugin ${pluginFullName} is not installed.`);

    if (localPlugin.isDev) utils.emitError(`Plugin ${pluginFullName} is a development version.`);

    if (utils.force) {
      uninstallPlugin(localSystem.folderName, pluginFullName, authorName);
      return;
    }

    const r1 = readline.createInterface({ input: process.stdin, output: process.stdout });
    r1.question(`Are you sure you want to uninstall the plugin ${pluginFullName}? (yes/no): `, (answer) => {
      if (answer === "yes") {
        console.log(`Uninstalling plugin ${pluginFullName} from system ${systemId}...`);
        uninstallPlugin(localSystem.folderName, pluginFullName, authorName);
      } else {
        console.log(`Uninstall canceled.`);
        process.exit(0);
      }
    });
  }
}

 function loadTimeFile(cb: (fd: TimePair[], p: string[]) => void, params: string[]){
   var clockfile, currentDeep, fileData, rd;
   clockfile = config.clockfile;
   if (!clockfile || !fs.existsSync(clockfile)) {
     println("You need to set the environment variable CLOCKFILE (pointing to an existing file)");
     process.exit(1);
   }
   currentDeep = 0;
   fileData = [];
   rd = readline.createInterface({
     input: fs.createReadStream(clockfile),
     output: process.stdout,
     terminal: false
   });
   rd.on('line', function(line){
     var l;
     l = parseLine(line, currentDeep);
     fileData.push(l);
     if (l.deep) {
       currentDeep = l.deep;
     }
   });
   rd.on('close', function(){
     cb(fileData, params);
   });
 };

        return new Promise((resolve) => {
            const io = this.io;
            const output = io.output;

            const options: readline.ReadLineOptions = {
                completer: (line: string) => {
                    const hits = question.getCompletions(line);
                    return [hits, line];
                },
                input: io.input.getStream(),
                terminal: output.isDecorated(),
            };

            if (!question.isHidden()) {
                options.output = output.getStream();
            }

            const rl = readline.createInterface(options);

            rl.question(question.getPrompt(), (answer) => {
                resolve(answer || "");

                rl.close();
            });
        });

virtualConnectionServer.createInterface(server).on('connection', (connection: Duplex) => {
    readline.createInterface(connection, null).on('line', line => {
        try {
            // Get a reference to the function to invoke
            const invocation = JSON.parse(line) as RpcInvocation;
            const invokedModule = dynamicRequire(path.resolve(process.cwd(), invocation.moduleName));
            const invokedFunction = invocation.exportedFunctionName ? invokedModule[invocation.exportedFunctionName] : invokedModule;

            // Actually invoke it, passing the callback followed by any supplied args
            const invocationCallback = (errorValue, successValue) => {
                connection.end(JSON.stringify({
                    result: successValue,
                    errorMessage: errorValue && (errorValue.message || errorValue),
                    errorDetails: errorValue && (errorValue.stack || null)
                }));
            };
            invokedFunction.apply(null, [invocationCallback].concat(invocation.args));
        } catch (ex) {
            connection.end(JSON.stringify({
                errorMessage: ex.message,
                errorDetails: ex.stack
            }));
        }
    });
});

  .then(user => {
    if (!user) {
      console.error('User unknown.')
      process.exit(-1)
    }

    const readline = require('readline')
    const Writable = require('stream').Writable
    const mutableStdout = new Writable({
      write: function (chunk, encoding, callback) {
        callback()
      }
    })
    const rl = readline.createInterface({
      input: process.stdin,
      output: mutableStdout,
      terminal: true
    })

    console.log('New password?')
    rl.on('line', function (password) {
      user.password = password

      user.save()
        .then(() => console.log('User password updated.'))
        .catch(err => console.error(err))
        .finally(() => process.exit(0))
    })
  })

	return new Promise<string>((resolve) => {
		const rl = readLine.createInterface(process.stdin, process.stdout);
		rl.question(message, (ans) => {
			resolve(ans);
			rl.close();
		});
	});

    public static read(filePath: string, featureSize:number, callback: Function, complete: Function = null): void {
        const options: Object = { encoding: 'utf8', highWaterMark: 256 };
        const stream: fs.ReadStream = fs.createReadStream(filePath, options);
        const rl: readline.ReadLine = readline.createInterface(stream, null);
        
        rl.on('line', (line: string) => {
            const fields: string[] = line.split(/[\s:]/);
            const label: number = fields[0].charAt(0) == '+' ? +1 : -1;
            const len: number = fields.length;
            let x: Feature | Float32Array = null;
            if (featureSize != null && featureSize > 0) {
                x = new Float32Array(featureSize).fill(0.0);
                for (let i = 1; i < len; i += 2) {
                    let index: number = parseInt(fields[i]) - 1;
                    let value: number = parseFloat(fields[i + 1]);
                    x[index] = value;
                }
            } else {
                x = [];
                for (let i = 1; i < len; i += 2) {
                    let index: number = parseInt(fields[i]) - 1;
                    let value: number = parseFloat(fields[i + 1]);
                    let element = { index, value };
                    x.push(element);
                }
            }
            callback(x, label);
        });

        rl.on('close', () => {
            if (complete instanceof Function) {
                complete();
            }
        });
    }