setInterval(() => {
   try {
     store.dispatch(actions.tick({}));
   } catch (e) {
     mainLogger.error(`While dispatching tick: ${e.stack}`);
   }
 }, 1 * 1000 /* every second */);

export function getTray(store: Store): Electron.Tray {
  if (!tray) {
    const iconPath = getImagePath(`tray/${env.appName}.png`);
    mainLogger.info(`Using tray image (${iconPath})`);
    let iconImage = nativeImage.createFromPath(iconPath);
    let onKDE = process.env.XDG_CURRENT_DESKTOP === "KDE";

    if (process.platform === "win32") {
      // cf. https://github.com/itchio/itch/issues/462
      // windows still displays a 16x16, whereas
      // some linux DEs don't know what to do with a @x2, etc.
      iconImage = iconImage.resize({
        width: 16,
        height: 16,
      });
    } else if (onKDE) {
      // KDE can't handle a 256x256 png apparently
      iconImage = iconImage.resize({
        width: 24,
        height: 24,
      });
    }

    tray = new Tray(iconImage);
    tray.setToolTip(env.appName);
    tray.on("click", () => {
      store.dispatch(actions.focusWind({ wind: "root", toggle: true }));
    });
    tray.on("double-click", () => {
      store.dispatch(actions.focusWind({ wind: "root" }));
    });
    tray.on("balloon-click", () => {
      if (lastNotificationAction) {
        store.dispatch(lastNotificationAction);
      }
    });
  }
  return tray;
}

import { actions } from "common/actions";
import urls from "common/constants/urls";
import { Store } from "common/types";
import { isItchioURL } from "common/util/url";
import { Watcher } from "common/util/watcher";
import { shell } from "electron";
import { mainLogger } from "main/logger";
import { modals } from "common/modals";
import urlParser from "url";
import querystring from "querystring";
import { doAsync } from "renderer/helpers/doAsync";
import { queueInstall } from "main/reactors/tasks/queue-game";
import { mcall } from "main/butlerd/mcall";
import { messages } from "common/butlerd";

const logger = mainLogger.child(__filename);

export default function(watcher: Watcher) {
  watcher.on(actions.processUrlArguments, async (store, action) => {
    const { args } = action.payload;
    for (const uri of args) {
      if (isItchioURL(uri)) {
        store.dispatch(actions.handleItchioURI({ uri }));
        break;
      }
    }
  });

  watcher.on(actions.openInExternalBrowser, async (store, action) => {
    const uri = action.payload.url;
    shell.openExternal(uri);

export function main() {
  mainLogger.info(
    `${env.appName}@${app.getVersion()} on electron@${
      process.versions.electron
    } in ${env.production ? "production" : "development"}`
  );

  if (process.env.CAPSULE_LIBRARY_PATH) {
    // disable acceleration when captured by capsule
    app.disableHardwareAcceleration();
  } else {
    try {
      const prefs = loadPreferencesSync();
      if (prefs.disableHardwareAcceleration) {
        app.disableHardwareAcceleration();
      }
    } catch (e) {
      // oh well
    }
  }

  if (env.production) {
    app.enableMixedSandbox();
  }

  // cf. https://github.com/itchio/itch/issues/2026
  app.commandLine.appendSwitch("ignore-connections-limit", "127.0.0.1");

  if (process.env.ITCH_IGNORE_CERTIFICATE_ERRORS === "1") {
    app.commandLine.appendSwitch("ignore-certificate-errors");
  }
  protocol.registerStandardSchemes(["itch-cave", "itch"]);

  let store: Store = require("main/store").default;

  let onReady = () => {
    if (!env.integrationTests) {
      const shouldQuit = app.makeSingleInstance((argv, cwd) => {
        // we only get inside this callback when another instance
        // is launched - so this executes in the context of the main instance
        store.dispatch(
          actions.processUrlArguments({
            args: argv,
          })
        );
        store.dispatch(actions.focusWind({ wind: "root" }));
      });
      if (shouldQuit) {
        app.exit(0);
        return;
      }
    }

    store.dispatch(
      actions.processUrlArguments({
        args: process.argv,
      })
    );

    globalShortcut.register("Control+Alt+Backspace", function() {
      store.dispatch(actions.forceCloseLastGame({}));
    });

    // Emitted when the application is activated. Various actions can trigger
    // this event, such as launching the application for the first time,
    // attempting to re-launch the application when it's already running, or
    // clicking on the application's dock or taskbar icon.
    app.on("activate", () => {
      store.dispatch(actions.focusWind({ wind: "root" }));
    });

    app.on("before-quit", e => {
      e.preventDefault();
      store.dispatch(actions.quit({}));
    });

    store.dispatch(actions.preboot({}));

    setInterval(() => {
      try {
        store.dispatch(actions.tick({}));
      } catch (e) {
        mainLogger.error(`While dispatching tick: ${e.stack}`);
      }
    }, 1 * 1000 /* every second */);
  };
  app.on("ready", onReady);

  app.on("will-finish-launching", () => {
    app.setAppUserModelId(appUserModelId);
  });

  // macOS (Info.pList)
  app.on("open-url", (e: Event, url: string) => {
    if (isItchioURL(url)) {
      // otherwise it'll err -600
      e.preventDefault();
      store.dispatch(actions.handleItchioURI({ uri: url }));
    }
  });
//.........这里部分代码省略.........

import { RequestCreator } from "butlerd";
import { call, SetupFunc } from "common/butlerd";
import store from "main/store";
import { mainLogger } from "main/logger";

if (process.type !== "browser") {
  throw new Error(`mcall cannot be required from renderer process`);
}

const logger = mainLogger.childWithName("mcall");

/**
 * Perform a butlerd call from the main process
 */
export async function mcall<Params, Res>(
  rc: RequestCreator<Params, Res>,
  params: {} & Params,
  setup?: SetupFunc
): Promise<Res> {
  return await call(store, logger, rc, params, setup);
}

import childProcess from "child_process";
import { formatExitCode } from "common/format/exit-code";
import { Logger } from "common/logger";
import { ItchPromise } from "common/util/itch-promise";
import { mainLogger } from "main/logger";
import split2 from "split2";
import stream from "stream";
import { MinimalContext } from "main/context";

const spawnLogger = mainLogger.child(__filename);

interface SpawnOpts {
  /** Context this should run in */
  ctx: MinimalContext;

  /** Command to spawn */
  command: string;

  /** Arguments */
  args: string[];

  /** Defaults to eol for the current platform ("\r\n" or "\n") */
  split?: string;

  /** Called when the process has been started and we're ready to write to stdin */
  onStdinReady?: (stdin: stream.Writable) => void;

  /** If set, called on each line of stdout */
  onToken?: (token: string) => void;

  /** If set, called on each line of stderr */

 watcher.on(actions.log, async (store, action) => {
   const { entry } = action.payload;
   mainLogger.write(entry);
 });

async function asTask(opts: AsTaskOpts) {
  const id = uuid();

  const { store, name, gameId, caveId } = opts;

  const logger = recordingLogger(mainLogger);

  store.dispatch(
    actions.taskStarted({
      id,
      name,
      gameId,
      caveId,
      startedAt: Date.now(),
    })
  );

  const ctx = new Context(store);
  ctx.registerTaskId(id);
  ctx.on("progress", (ev: ProgressInfo) => {
    store.dispatch(actions.taskProgress({ id, ...ev }));
  });

  getCurrentTasks()[id] = ctx;

  let err: Error;

  const { work, onError, onCancel } = opts;

  try {
    await work(ctx, logger);
  } catch (e) {
    err = e;
  }

  delete getCurrentTasks()[id];

  if (err) {
    if (isCancelled(err)) {
      mainLogger.warn(`Task ${name} cancelled`);
      if (onCancel) {
        await onCancel();
      }
    } else if (isAborted(err)) {
      mainLogger.warn(`Task ${name} aborted`);
      if (onCancel) {
        await onCancel();
      }
    } else {
      mainLogger.warn(`Task ${name} threw: ${err.stack}`);
      if (onError) {
        await onError(err, logger.getLog());
      }
    }
  }

  store.dispatch(
    actions.taskEnded({
      id,
      err: err ? `${err}` : null,
    })
  );
}