gestament 0.1.0 → 0.3.0

package/dist/gestament-launcher-driver.cjs

@@ -0,0 +1,656 @@
+#!/usr/bin/env node
+"use strict";
+const node_child_process = require("node:child_process");
+const node_net = require("node:net");
+const node_fs = require("node:fs");
+const node_path = require("node:path");
+const errors = require("./errors-6gj5YuLw.cjs");
+const launchGtkApp = require("./launchGtkApp-BIO_5Xjn.cjs");
+const wait = require("./wait-eOIz4nZm.cjs");
+const trayHostReadyLine = "gestament-tray-host-ready";
+const trayHostReadyTimeoutMs = 3e4;
+const apps = /* @__PURE__ */ new Map();
+const elements = /* @__PURE__ */ new Map();
+const trayItems = /* @__PURE__ */ new Map();
+const imageInfos = /* @__PURE__ */ new Map();
+const staleElementIds = /* @__PURE__ */ new Set();
+const staleTrayItemIds = /* @__PURE__ */ new Set();
+const staleImageInfoIds = /* @__PURE__ */ new Set();
+let nextAppId = 1;
+let nextElementId = 1;
+let nextTrayItemId = 1;
+let nextImageInfoId = 1;
+let shuttingDown = false;
+let trayHostProcess;
+const parseArguments = (args) => {
+  let socketPath;
+  let withTrayHost = false;
+  let index = 0;
+  while (index < args.length) {
+    const argument = args[index];
+    if (argument === "--socket") {
+      const value = args[index + 1];
+      if (value === void 0 || value.length === 0) {
+        throw new Error("--socket requires a Unix socket path.");
+      }
+      socketPath = value;
+      index += 2;
+      continue;
+    }
+    if (argument === "--with-tray-host") {
+      withTrayHost = true;
+      index += 1;
+      continue;
+    }
+    throw new Error(`Unknown gestament launcher driver option: ${argument}`);
+  }
+  if (socketPath === void 0) {
+    throw new Error("Missing --socket option.");
+  }
+  return { socketPath, withTrayHost };
+};
+const waitForTrayHostReady = (host) => new Promise((resolveReady, rejectReady) => {
+  if (host.stdout === null) {
+    rejectReady(new Error("gestament tray host did not expose stdout."));
+    return;
+  }
+  let output = "";
+  let settled = false;
+  const timeout = setTimeout(() => {
+    if (!settled) {
+      settled = true;
+      rejectReady(new Error("Timed out waiting for gestament tray host."));
+    }
+  }, trayHostReadyTimeoutMs);
+  host.stdout.on("data", (chunk) => {
+    const text = chunk.toString("utf8");
+    output += text;
+    if (!settled && output.includes(trayHostReadyLine)) {
+      settled = true;
+      clearTimeout(timeout);
+      resolveReady();
+      return;
+    }
+    if (settled) {
+      process.stdout.write(text);
+    }
+  });
+  host.once("exit", (code, signal) => {
+    if (!settled) {
+      settled = true;
+      clearTimeout(timeout);
+      rejectReady(
+        new Error(
+          `gestament tray host exited before ready: code=${String(
+            code
+          )}, signal=${String(signal)}`
+        )
+      );
+    }
+  });
+  host.once("error", (error) => {
+    if (!settled) {
+      settled = true;
+      clearTimeout(timeout);
+      rejectReady(error);
+    }
+  });
+});
+const startTrayHost = async () => {
+  const executablePath = process.argv[1];
+  if (executablePath === void 0) {
+    throw new Error("Missing executable path.");
+  }
+  const hostPath = node_path.resolve(
+    node_path.dirname(node_fs.realpathSync(executablePath)),
+    "gestament-tray-host.cjs"
+  );
+  const host = node_child_process.spawn(process.execPath, [hostPath], {
+    env: process.env,
+    stdio: ["ignore", "pipe", "inherit"]
+  });
+  try {
+    await waitForTrayHostReady(host);
+    return host;
+  } catch (error) {
+    if (host.exitCode === null && host.signalCode === null) {
+      host.kill("SIGTERM");
+    }
+    throw error;
+  }
+};
+const connectToParent = (socketPath) => new Promise((resolveConnect, rejectConnect) => {
+  const socket = node_net.createConnection(socketPath);
+  const rejectFromError = (error) => {
+    socket.removeListener("connect", resolveFromConnect);
+    rejectConnect(error);
+  };
+  const resolveFromConnect = () => {
+    socket.removeListener("error", rejectFromError);
+    resolveConnect(socket);
+  };
+  socket.once("error", rejectFromError);
+  socket.once("connect", resolveFromConnect);
+});
+const writeReady = (socket) => {
+  const ready = { type: "ready" };
+  socket.write(`${JSON.stringify(ready)}
+`);
+};
+const wireEnvironmentToGtkAppEnvironment = (env) => {
+  const appEnv = {};
+  for (const [key, value] of Object.entries(env)) {
+    appEnv[key] = value === null ? void 0 : value;
+  }
+  return appEnv;
+};
+const toWireCapture = (capture) => ({
+  bounds: capture.bounds,
+  clipped: capture.clipped,
+  imageBase64: capture.image.toString("base64"),
+  visibleBounds: capture.visibleBounds
+});
+const registerApp = (app) => {
+  const appId = `app-${nextAppId}`;
+  nextAppId += 1;
+  apps.set(appId, app);
+  return { appId };
+};
+const registerElement = (appId, element) => {
+  const elementId = `element-${nextElementId}`;
+  nextElementId += 1;
+  elements.set(elementId, { appId, element });
+  return { elementId, kind: element.kind };
+};
+const registerTrayItem = (appId, trayItem) => {
+  const trayItemId = `tray-${nextTrayItemId}`;
+  nextTrayItemId += 1;
+  trayItems.set(trayItemId, { appId, trayItem });
+  return { trayItemId };
+};
+const registerImageInfo = (appId, info) => {
+  const imageInfoId = `image-info-${nextImageInfoId}`;
+  nextImageInfoId += 1;
+  imageInfos.set(imageInfoId, { appId, capture: info.capture });
+  return {
+    bounds: info.bounds,
+    description: info.description,
+    imageInfoId,
+    locale: info.locale,
+    position: info.position,
+    size: info.size
+  };
+};
+const resolveApp = (appId) => {
+  const app = apps.get(appId);
+  if (app === void 0) {
+    throw errors.createGtkAppExitedError(
+      "GTK application has exited or was released."
+    );
+  }
+  return app;
+};
+const resolveElementEntry = (elementId) => {
+  const entry = elements.get(elementId);
+  if (entry === void 0) {
+    if (staleElementIds.has(elementId)) {
+      throw errors.createGtkStaleElementError("GTK element is no longer available.");
+    }
+    throw errors.createGtkAppExitedError("GTK element is not registered.");
+  }
+  if (!apps.has(entry.appId)) {
+    throw errors.createGtkStaleElementError("GTK element is no longer available.");
+  }
+  return entry;
+};
+const resolveTrayItemEntry = (trayItemId) => {
+  const entry = trayItems.get(trayItemId);
+  if (entry === void 0) {
+    if (staleTrayItemIds.has(trayItemId)) {
+      throw errors.createGtkStaleElementError("Tray item is no longer registered.");
+    }
+    throw errors.createGtkAppExitedError("GTK tray item is not registered.");
+  }
+  if (!apps.has(entry.appId)) {
+    throw errors.createGtkStaleElementError("Tray item is no longer registered.");
+  }
+  return entry;
+};
+const resolveImageInfoEntry = (imageInfoId) => {
+  const entry = imageInfos.get(imageInfoId);
+  if (entry === void 0) {
+    if (staleImageInfoIds.has(imageInfoId)) {
+      throw errors.createGtkStaleElementError(
+        "GTK image info is no longer available."
+      );
+    }
+    throw errors.createGtkAppExitedError("GTK image info is not registered.");
+  }
+  if (!apps.has(entry.appId)) {
+    throw errors.createGtkStaleElementError("GTK image info is no longer available.");
+  }
+  return entry;
+};
+const removeAppRefs = (appId) => {
+  for (const [elementId, entry] of elements) {
+    if (entry.appId === appId) {
+      staleElementIds.add(elementId);
+      elements.delete(elementId);
+    }
+  }
+  for (const [trayItemId, entry] of trayItems) {
+    if (entry.appId === appId) {
+      staleTrayItemIds.add(trayItemId);
+      trayItems.delete(trayItemId);
+    }
+  }
+  for (const [imageInfoId, entry] of imageInfos) {
+    if (entry.appId === appId) {
+      staleImageInfoIds.add(imageInfoId);
+      imageInfos.delete(imageInfoId);
+    }
+  }
+};
+const releaseApp = async (appId) => {
+  const app = apps.get(appId);
+  if (app === void 0) {
+    return;
+  }
+  apps.delete(appId);
+  removeAppRefs(appId);
+  await app.release();
+};
+const releaseApps = async () => {
+  const appIds = [...apps.keys()];
+  await Promise.all(appIds.map((appId) => releaseApp(appId)));
+};
+const stopTrayHost = () => {
+  if (trayHostProcess !== void 0 && trayHostProcess.exitCode === null && trayHostProcess.signalCode === null) {
+    trayHostProcess.kill("SIGTERM");
+  }
+};
+const releaseAll = async () => {
+  await releaseApps();
+  stopTrayHost();
+};
+const asMethod = (target, methodName, kindLabel) => {
+  const value = target[methodName];
+  if (typeof value !== "function") {
+    throw errors.createGtkUnsupportedInterfaceError(
+      `${kindLabel} does not support ${methodName}().`
+    );
+  }
+  return value;
+};
+const callElementMethod = (entry, methodName, args = []) => asMethod(
+  entry.element,
+  methodName,
+  `GTK ${entry.element.kind} element`
+)(...args);
+const callTrayItemMethod = (entry, methodName, args = []) => asMethod(entry.trayItem, methodName, "GTK tray item")(...args);
+const serializeError = (error) => {
+  if (error instanceof Error) {
+    const maybeCode = error.code;
+    const base = {
+      message: error.message,
+      name: error.name
+    };
+    const withStack = error.stack === void 0 ? base : { ...base, stack: error.stack };
+    return typeof maybeCode === "string" ? { ...withStack, code: maybeCode } : withStack;
+  }
+  return {
+    message: String(error),
+    name: "Error"
+  };
+};
+const appPayload = (payload) => payload;
+const elementPayload = (payload) => payload;
+const trayPayload = (payload) => payload;
+const optionalElementRef = (appId, element) => element === void 0 ? null : registerElement(appId, element);
+const optionalTrayItemRef = (appId, trayItem) => trayItem === void 0 ? null : registerTrayItem(appId, trayItem);
+const handleLauncherCommand = async (command, payload) => {
+  switch (command) {
+    case "launcher.launch": {
+      const launchPayload = payload;
+      const launchOptions = {
+        env: wireEnvironmentToGtkAppEnvironment(launchPayload.env),
+        ...launchPayload.timeoutMs === null ? {} : { timeoutMs: launchPayload.timeoutMs }
+      };
+      const app = await launchGtkApp.launchGtkApp(
+        launchPayload.appPath,
+        launchPayload.args,
+        launchOptions
+      );
+      return registerApp(app);
+    }
+    case "launcher.release":
+      await releaseAll();
+      return null;
+    case "launcher.reset":
+      await releaseApps();
+      return {
+        appCount: apps.size,
+        elementCount: elements.size,
+        imageInfoCount: imageInfos.size,
+        trayItemCount: trayItems.size
+      };
+    default:
+      throw errors.createGtkOperationFailedError(`Unsupported command: ${command}`);
+  }
+};
+const handleAppCommand = async (command, payload) => {
+  const { appId } = appPayload(payload);
+  const app = resolveApp(appId);
+  switch (command) {
+    case "app.release":
+      await releaseApp(appId);
+      return null;
+    case "app.capture":
+      return toWireCapture(await app.capture());
+    case "app.findById": {
+      const { id } = payload;
+      return optionalElementRef(appId, await app.findById(id));
+    }
+    case "app.getById": {
+      const { id } = payload;
+      return registerElement(appId, await app.getById(id));
+    }
+    case "app.findByPath": {
+      const { path } = payload;
+      return optionalElementRef(appId, await app.findByPath(path));
+    }
+    case "app.getByPath": {
+      const { path } = payload;
+      return registerElement(appId, await app.getByPath(path));
+    }
+    case "app.windowAt": {
+      const { index } = payload;
+      return optionalElementRef(appId, await app.windowAt(index));
+    }
+    case "app.getWindowCount":
+      return app.getWindowCount();
+    case "app.findTrayItem": {
+      const { selector } = payload;
+      return optionalTrayItemRef(appId, await app.findTrayItem(selector));
+    }
+    case "app.getTrayItem": {
+      const { selector } = payload;
+      return registerTrayItem(appId, await app.getTrayItem(selector));
+    }
+    case "app.trayItemAt": {
+      const { index } = payload;
+      return optionalTrayItemRef(appId, await app.trayItemAt(index));
+    }
+    case "app.getTrayItemCount":
+      return app.getTrayItemCount();
+    default:
+      throw errors.createGtkOperationFailedError(
+        `Unsupported app command: ${command}`
+      );
+  }
+};
+const handleElementCommand = async (command, payload) => {
+  const { elementId } = elementPayload(payload);
+  const entry = resolveElementEntry(elementId);
+  switch (command) {
+    case "element.info":
+      return entry.element.info();
+    case "element.capture":
+      return toWireCapture(await entry.element.capture());
+    case "element.childAt": {
+      const { index } = payload;
+      return optionalElementRef(
+        entry.appId,
+        await callElementMethod(entry, "childAt", [index])
+      );
+    }
+    case "element.getChildCount":
+      return callElementMethod(entry, "getChildCount");
+    case "element.click":
+      await callElementMethod(entry, "click");
+      return null;
+    case "element.text":
+      return callElementMethod(entry, "text");
+    case "element.setText": {
+      const { text } = payload;
+      await callElementMethod(entry, "setText", [text]);
+      return null;
+    }
+    case "element.isChecked":
+      return callElementMethod(entry, "isChecked");
+    case "element.toggle":
+      await callElementMethod(entry, "toggle");
+      return null;
+    case "element.value":
+      return callElementMethod(entry, "value");
+    case "element.valueInfo":
+      return callElementMethod(entry, "valueInfo");
+    case "element.setValue": {
+      const { value } = payload;
+      await callElementMethod(entry, "setValue", [value]);
+      return null;
+    }
+    case "element.increment":
+      await callElementMethod(entry, "increment");
+      return null;
+    case "element.decrement":
+      await callElementMethod(entry, "decrement");
+      return null;
+    case "element.getSelectedChildCount":
+      return callElementMethod(entry, "getSelectedChildCount");
+    case "element.selectedChildAt": {
+      const { selectedIndex } = payload;
+      return optionalElementRef(
+        entry.appId,
+        await callElementMethod(entry, "selectedChildAt", [selectedIndex])
+      );
+    }
+    case "element.isChildSelected": {
+      const { index } = payload;
+      return callElementMethod(entry, "isChildSelected", [index]);
+    }
+    case "element.selectChildAt": {
+      const { index } = payload;
+      await callElementMethod(entry, "selectChildAt", [index]);
+      return null;
+    }
+    case "element.deselectChildAt": {
+      const { index } = payload;
+      await callElementMethod(entry, "deselectChildAt", [index]);
+      return null;
+    }
+    case "element.selectAllChildren":
+      await callElementMethod(entry, "selectAllChildren");
+      return null;
+    case "element.clearSelection":
+      await callElementMethod(entry, "clearSelection");
+      return null;
+    case "element.getRowCount":
+      return callElementMethod(entry, "getRowCount");
+    case "element.getColumnCount":
+      return callElementMethod(entry, "getColumnCount");
+    case "element.cellAt": {
+      const { column, row } = payload;
+      return optionalElementRef(
+        entry.appId,
+        await callElementMethod(entry, "cellAt", [row, column])
+      );
+    }
+    case "element.selectedRows":
+      return callElementMethod(entry, "selectedRows");
+    case "element.selectedColumns":
+      return callElementMethod(entry, "selectedColumns");
+    case "element.isRowSelected": {
+      const { row } = payload;
+      return callElementMethod(entry, "isRowSelected", [row]);
+    }
+    case "element.isColumnSelected": {
+      const { column } = payload;
+      return callElementMethod(entry, "isColumnSelected", [column]);
+    }
+    case "element.isCellSelected": {
+      const { column, row } = payload;
+      return callElementMethod(entry, "isCellSelected", [row, column]);
+    }
+    case "element.selectRow": {
+      const { row } = payload;
+      await callElementMethod(entry, "selectRow", [row]);
+      return null;
+    }
+    case "element.deselectRow": {
+      const { row } = payload;
+      await callElementMethod(entry, "deselectRow", [row]);
+      return null;
+    }
+    case "element.selectColumn": {
+      const { column } = payload;
+      await callElementMethod(entry, "selectColumn", [column]);
+      return null;
+    }
+    case "element.deselectColumn": {
+      const { column } = payload;
+      await callElementMethod(entry, "deselectColumn", [column]);
+      return null;
+    }
+    case "element.imageInfo": {
+      const info = await callElementMethod(
+        entry,
+        "imageInfo"
+      );
+      return registerImageInfo(entry.appId, info);
+    }
+    default:
+      throw errors.createGtkOperationFailedError(
+        `Unsupported element command: ${command}`
+      );
+  }
+};
+const handleImageInfoCommand = async (command, payload) => {
+  if (command !== "imageInfo.capture") {
+    throw errors.createGtkOperationFailedError(
+      `Unsupported image info command: ${command}`
+    );
+  }
+  const { imageInfoId } = payload;
+  const entry = resolveImageInfoEntry(imageInfoId);
+  return toWireCapture(await entry.capture());
+};
+const handleTrayCommand = async (command, payload) => {
+  const { trayItemId } = trayPayload(payload);
+  const entry = resolveTrayItemEntry(trayItemId);
+  switch (command) {
+    case "tray.metadata":
+      return entry.trayItem.metadata();
+    case "tray.element":
+      return optionalElementRef(
+        entry.appId,
+        await callTrayItemMethod(entry, "element")
+      );
+    case "tray.capture":
+      return toWireCapture(await entry.trayItem.capture());
+    case "tray.click":
+      await entry.trayItem.click();
+      return null;
+    case "tray.openMenu":
+      return optionalElementRef(
+        entry.appId,
+        await callTrayItemMethod(entry, "openMenu")
+      );
+    default:
+      throw errors.createGtkOperationFailedError(
+        `Unsupported tray command: ${command}`
+      );
+  }
+};
+const handleRequest = async (request) => {
+  if (request.command.startsWith("launcher.")) {
+    return handleLauncherCommand(request.command, request.payload);
+  }
+  if (request.command.startsWith("app.")) {
+    return handleAppCommand(request.command, request.payload);
+  }
+  if (request.command.startsWith("element.")) {
+    return handleElementCommand(request.command, request.payload);
+  }
+  if (request.command.startsWith("imageInfo.")) {
+    return handleImageInfoCommand(request.command, request.payload);
+  }
+  if (request.command.startsWith("tray.")) {
+    return handleTrayCommand(request.command, request.payload);
+  }
+  throw errors.createGtkOperationFailedError(
+    `Unsupported launcher driver command: ${request.command}`
+  );
+};
+const writeResponse = (socket, id, response) => {
+  socket.write(`${JSON.stringify({ id, ...response })}
+`);
+};
+const handleRequestLine = async (socket, line) => {
+  const request = JSON.parse(line);
+  try {
+    const value = request.deadlineMs === void 0 || request.deadlineMs === null ? await handleRequest(request) : await wait.runWithWaitDeadline(
+      request.deadlineMs,
+      () => handleRequest(request)
+    );
+    writeResponse(socket, request.id, { ok: true, value });
+    if (request.command === "launcher.release") {
+      socket.end();
+    }
+  } catch (error) {
+    writeResponse(socket, request.id, {
+      error: serializeError(error),
+      ok: false
+    });
+  }
+};
+const installSocketProtocol = (socket) => {
+  let input = "";
+  socket.on("data", (chunk) => {
+    input += chunk.toString("utf8");
+    let newlineIndex = input.indexOf("\n");
+    while (newlineIndex >= 0) {
+      const line = input.slice(0, newlineIndex);
+      input = input.slice(newlineIndex + 1);
+      void handleRequestLine(socket, line);
+      newlineIndex = input.indexOf("\n");
+    }
+  });
+  socket.once("close", () => {
+    void shutdown(0);
+  });
+  socket.once("error", () => {
+    void shutdown(1);
+  });
+};
+const shutdown = async (exitCode) => {
+  if (shuttingDown) {
+    return;
+  }
+  shuttingDown = true;
+  await releaseAll();
+  process.exitCode = exitCode;
+  setImmediate(() => {
+    process.exit(exitCode);
+  });
+};
+const run = async () => {
+  const parsed = parseArguments(process.argv.slice(2));
+  trayHostProcess = parsed.withTrayHost ? await startTrayHost() : void 0;
+  const socket = await connectToParent(parsed.socketPath);
+  installSocketProtocol(socket);
+  writeReady(socket);
+  process.once("SIGINT", () => {
+    void shutdown(130);
+  });
+  process.once("SIGTERM", () => {
+    void shutdown(143);
+  });
+};
+run().catch((error) => {
+  const message = error instanceof Error ? error.message : String(error);
+  process.stderr.write(`gestament launcher driver: ${message}
+`);
+  process.exitCode = 2;
+});
+//# sourceMappingURL=gestament-launcher-driver.cjs.map