macOS

import { app, utilityProcess } from "electron";
import { randomBytes } from "node:crypto";
import { createWriteStream, mkdirSync } from "node:fs";
import { createRequire } from "node:module";
import { createServer } from "node:net";
import { join } from "node:path";

const require = createRequire(import.meta.url);

/** Ask the OS for a free loopback port. */
function findFreePort() {
  return new Promise((resolve, reject) => {
    const probe = createServer();
    probe.once("error", reject);
    probe.listen(0, "127.0.0.1", () => {
      const { port } = probe.address();
      probe.close(() => resolve(port));
    });
  });
}

export class ZeroGpuWorker {
  #child = null;
  #log = null;
  #exited = null;
  #starting = null;
  #port = 0;
  #token = "";

  constructor({ operatorKey, environment = "production", logLevel = "warn", onExit }) {
    this.operatorKey = operatorKey;
    this.environment = environment;
    this.logLevel = logLevel;
    this.onExit = onExit;
  }

  get running() {
    return this.#child !== null;
  }

  /** Start the worker. Idempotent; safe to call repeatedly. */
  start() {
    this.#starting ??= this.#spawn().finally(() => {
      this.#starting = null;
    });
    return this.#starting;
  }

  async #spawn() {
    if (this.#child) return;
    const stateDir = join(app.getPath("userData"), "zerogpu");
    mkdirSync(stateDir, { recursive: true });
    this.#port = await findFreePort();
    this.#token = randomBytes(24).toString("hex");

    const child = utilityProcess.fork(require.resolve("@zerogpu/worker/cli"), [], {
      serviceName: "ZeroGPU Worker",
      stdio: "pipe",
      env: {
        ...process.env,
        ZG_OPERATOR_KEY: this.operatorKey,
        ZG_ENV: this.environment,
        ZG_LOCAL_API_PORT: String(this.#port),
        ZG_LOCAL_API_TOKEN: this.#token,
        ZG_MODELS_DIR: join(stateDir, "models"),
        ZG_DATA_DIR: join(stateDir, "data"),
        ZG_MAX_CONCURRENCY: "1",
        ZG_LOG_LEVEL: this.logLevel,
      },
    });

    this.#log ??= createWriteStream(join(app.getPath("logs"), "zerogpu-worker.log"), { flags: "a" });
    child.stdout?.pipe(this.#log, { end: false });
    child.stderr?.pipe(this.#log, { end: false });

    this.#exited = new Promise((resolve) => {
      child.once("exit", (code) => {
        if (this.#child === child) this.#child = null;
        this.onExit?.(code);
        resolve(code);
      });
    });
    this.#child = child;
  }

  /** Worker health: lifecycle status, model states, served/network counters. */
  async status() {
    if (!this.#child) return { running: false, ready: false };
    try {
      const res = await fetch(`http://127.0.0.1:${this.#port}/healthz`, {
        signal: AbortSignal.timeout(2000),
      });
      return { running: true, ...(await res.json()) };
    } catch {
      return { running: true, ready: false, status: "starting" };
    }
  }

  /** Stop the worker: it leaves the network cleanly, then exits (≤ 5 s). */
  async stop(timeoutMs = 7000) {
    await this.#starting;
    const child = this.#child;
    if (!child) return;
    this.#child = null;
    child.kill(); // SIGTERM → graceful shutdown
    await Promise.race([this.#exited, new Promise((resolve) => setTimeout(resolve, timeoutMs))]);
  }
}

import { app, powerMonitor } from "electron";

import { ZEROGPU_OPERATOR_KEY } from "./build-config.mjs"; // generated at build time, not committed
import { ZeroGpuWorker } from "./zerogpu-worker.mjs";

const worker = new ZeroGpuWorker({
  operatorKey: ZEROGPU_OPERATOR_KEY,
  logLevel: app.isPackaged ? "warn" : "info",
});

const startIfOnPower = () => {
  if (!powerMonitor.isOnBatteryPower()) void worker.start();
};

app.whenReady().then(() => {
  startIfOnPower();
  powerMonitor.on("on-ac", startIfOnPower);
  powerMonitor.on("resume", startIfOnPower);
  powerMonitor.on("on-battery", () => void worker.stop());
  powerMonitor.on("suspend", () => void worker.stop());
});

let workerStopped = false;
app.on("before-quit", (event) => {
  if (workerStopped) return;
  event.preventDefault();
  worker.stop().finally(() => {
    workerStopped = true;
    app.quit();
  });
});

{
  "build": {
    "asar": true,
    "asarUnpack": [
      "**/node_modules/onnxruntime-node/**/*",
      "**/node_modules/sharp/**/*",
      "**/node_modules/@img/**/*",
      "**/node_modules/node-llama-cpp/**/*",
      "**/node_modules/@node-llama-cpp/**/*"
    ],
    "mac": {
      "target": [{ "target": "dmg", "arch": ["arm64", "x64"] }],
      "notarize": true
    }
  }
}