app.on('ready', () => {
  if (debugMode) {
    Menu.setApplicationMenu(Menu.buildFromTemplate([{
      label: 'Developer',
      submenu: [{role: 'reload'}, {role: 'forcereload'}, {role: 'toggledevtools'}]
    }]));
  } else {
    checkForUpdates();

    // Check every six hours
    setInterval(checkForUpdates, 6 * 60 * 60 * 1000);
  }

  // Set the app to launch at startup to connect automatically in case of a showdown while proxying.
  if (isLinux) {
    if (process.env.APPIMAGE) {
      const outlineAutoLauncher = new autoLaunch({
        name: 'OutlineClient',
        path: process.env.APPIMAGE,
      });

      outlineAutoLauncher.isEnabled()
          .then((isEnabled: boolean) => {
            if (isEnabled) {
              return;
            }
            outlineAutoLauncher.enable();
          })
          .catch((err: Error) => {
            console.error(`failed to add autolaunch entry for Outline ${err.message}`);
          });
    }
  } else {
    app.setLoginItemSettings({openAtLogin: true, args: [Options.AUTOSTART]});
  }

  // TODO: --autostart is never set on Linux, what can we do?
  if (process.argv.includes(Options.AUTOSTART)) {
    connectionStore.load()
        .then((connection) => {
          createWindow(connection);
        })
        .catch((e) => {
          // No connection at shutdown, or failure - either way, no need to start.
          // TODO: Instead of quitting, how about creating the system tray icon?
          console.log(`${Options.AUTOSTART} was passed but we were not connected at shutdown - exiting`);
          app.quit();
        });
  } else {
    createWindow();
  }
});

app.on('ready', () => {
  // TODO: Run this periodically, e.g. every 4-6 hours.
  autoUpdater.checkForUpdates();

  if (debugMode) {
    Menu.setApplicationMenu(Menu.buildFromTemplate([{
      label: 'Developer',
      submenu: [{role: 'reload'}, {role: 'forcereload'}, {role: 'toggledevtools'}]
    }]));
  }

  // Set the app to launch at startup to reset the system proxy configuration
  // in case of a showdown while proxying.
  app.setLoginItemSettings({openAtLogin: true, args: [Options.AUTOSTART]});

  if (process.argv.includes(Options.AUTOSTART)) {
    app.quit();  // Quitting the app will reset the system proxy configuration before exiting.
  } else {
    createWindow();
  }
});

import * as lsp from 'vscode-languageserver-protocol'
import * as lspt from 'vscode-languageserver-types'
import {Position} from 'vscode-languageserver-types'
import * as rpc from 'vscode-jsonrpc'
import * as fs from 'fs'
import * as path from 'path'
import * as cp from 'child_process'
import * as process from 'process'
import * as libkak from './libkak'
import {Splice, subkeys, Kak} from './libkak'
import * as util from 'util'
util.inspect.defaultOptions.depth = 5

const session = process.argv[2]
const server = process.argv[3]
const proto_args = process.argv.slice(4)
const args = proto_args.filter(arg => arg != '-d')

const debug = proto_args.some(arg => arg == '-d')
const debug_values = debug
const debug_out = debug
const debug_to_kakoune = debug
const debug_connection = debug

if (!session || !server) {
  console.error(`Need two arguments:

    <kak session>
    <server command>

  Example:

import {
  AUTO_START_ARG,
  TypeChecker,
} from './type_checker';
import {
  InitMessage,
  MESSAGE_KIND,
  TypeCheckerMessage,
  UpdateMessage,
} from './type_checker_messages';

let typeChecker: TypeChecker;
let lastCancellationToken: CancellationToken;

// only listen to messages if started from the AngularCompilerPlugin
if (process.argv.indexOf(AUTO_START_ARG) >= 0) {
  process.on('message', (message: TypeCheckerMessage) => {
    time('TypeChecker.message');
    switch (message.kind) {
      case MESSAGE_KIND.Init:
        const initMessage = message as InitMessage;
        typeChecker = new TypeChecker(
          initMessage.compilerOptions,
          initMessage.basePath,
          initMessage.jitMode,
          initMessage.rootNames,
          initMessage.hostReplacementPaths,
        );
        break;
      case MESSAGE_KIND.Update:
        if (!typeChecker) {

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/

import { argv } from "process";
import { Log } from "../src/log";
import * as WhyRunning from "why-is-node-running";

const logger = new Log("MessageProcessor");

// we are a test file and thus need those
/* tslint:disable:no-unused-expression max-file-line-count */

if (!argv.includes("--noisy")) {
    Log.ForceSilent();
}

after(() => {
    WhyRunning();
});

// print process.argv
declare function require(name:string);

var process = require('Process');

process.argv.forEach(function(val, index, array) {
  console.log(index + ': ' + val);
});

const maxOldSpaceSizeArg = process.execArgv.find(arg =>
  arg.includes("--max_old_space_size")
);
const inspectArg = process.execArgv.find(arg => arg.includes("--inspect"));

if (!maxOldSpaceSizeArg) {
  // Analysis etc can sometimes use lots of memory, so raise the memory threshold
  const fork = require("child_process").fork;
  const execArgv = process.execArgv;
  execArgv.push("--max_old_space_size=8000");
  if (inspectArg) {
    // set new port because otherwise it'll say port already in use
    execArgv.push("--inspect=36689");
  }
  const childWithMoreMemory = fork(process.argv[1], process.argv.slice(2), {
    execArgv
  });
  childWithMoreMemory.on("exit", function() {
    process.exit();
  });
  process["titl" + "e"] =
    "FromJS (launched CLI process with too low memory limit)";
} else {
  commander
    .option("--openBrowser <shouldOpen>", "yes|no|only", "yes")
    .option("-p, --port <port>", "Server port", 7000)
    .option(
      "-s, --sessionDirectory <sessionDirectory>",
      "Where to store tracking data",
      "fromjs-session"

export const hasProcessFlag = flag => process.argv.join('').indexOf(flag) > -1;