// @effect-diagnostics globalTimers:off -- D-Bus deadlines run at a native async boundary.// @effect-diagnostics nodeBuiltinImport:off -- Read the portal file through one bounded file descriptor at the native adapter boundary. import * as NodeCrypto from "node:crypto";import {  DBusError,  Message,  MessageFlag,  MessageType,  NameFlag,  RequestNameReply,  Variant,  sessionBus,  type MessageBus,  type MessageLike,} from "dbus-next";import * as Schema from "effect/Schema";import { isKdeCaptureSession, type KdeCapturePaths } from "./KdeSnapShot.ts";import { isGnomeCaptureSession, readPortalPng, resizeLinuxCapture } from "./linuxCaptureSession.ts";export { readPortalPng, resizeLinuxCapture } from "./linuxCaptureSession.ts";import { isHyprlandCaptureSession, type HyprlandCapturePaths } from "./HyprlandSnapShot.ts"; const PORTAL = "org.freedesktop.portal.Desktop";const PORTAL_PATH = "/org/freedesktop/portal/desktop";const SCREENSHOT = "org.freedesktop.portal.Screenshot";const REQUEST = "org.freedesktop.portal.Request";const EXTENSION = "org.gnome.Shell.Extensions.T3SnapShot";const EXTENSION_PATH = "/org/gnome/Shell/Extensions/T3SnapShot";const DBUS = "org.freedesktop.DBus";const DBUS_PATH = "/org/freedesktop/DBus";const UInt = Schema.Int.check(Schema.isBetween({ minimum: 0, maximum: 0xffff_ffff }));const UIntVariant = Schema.Struct({ signature: Schema.Literal("u"), value: UInt });const StringVariant = Schema.Struct({ signature: Schema.Literal("s"), value: Schema.String });const PortalProperties = Schema.Struct({  version: UIntVariant,  AvailableTargets: Schema.optional(UIntVariant),});const WindowMetadata = Schema.Struct({  title: Schema.String,  appName: Schema.String,  appIdentifier: Schema.String,  processId: UInt,  bounds: Schema.Struct({    x: Schema.Int,    y: Schema.Int,    width: Schema.Int.check(Schema.isGreaterThan(0)),    height: Schema.Int.check(Schema.isGreaterThan(0)),  }),});export type LinuxWindowMetadata = typeof WindowMetadata.Type & {  readonly clientBounds?: typeof WindowMetadata.Type.bounds;  readonly accessibilityBoundsReliable?: boolean;};const decodeProperties = Schema.decodeUnknownSync(PortalProperties);const decodeExtension = Schema.decodeUnknownSync(Schema.Struct({ Version: UIntVariant }));const decodeKde = Schema.decodeUnknownSync(Schema.Struct({ Version: UIntVariant }));const decodeString = Schema.decodeUnknownSync(Schema.String);const decodeBoolean = Schema.decodeUnknownSync(Schema.Boolean);const decodeResponse = Schema.decodeUnknownSync(  Schema.Tuple([UInt, Schema.Record(Schema.String, Schema.Unknown)]),);const decodeUri = Schema.decodeUnknownSync(StringVariant);const decodeWindow = Schema.decodeUnknownSync(Schema.fromJsonString(WindowMetadata));export type LinuxCaptureBackend =  | "screenshot-portal"  | "gnome-extension"  | "niri"  | "kde"  | "hyprland"  | "picker";export type LinuxWindowSnapshot = {  readonly png: Buffer;  readonly window?: LinuxWindowMetadata;  readonly feedback?: LinuxCaptureFeedback;}; export type LinuxCaptureFeedback = {  readonly animationStarted: boolean;  readonly activate: (title: string) => Promise<void>;  readonly animateTo: (frame: {    x: number;    y: number;    width: number;    height: number;  }) => Promise<void>;  readonly complete: () => Promise<void>;  readonly close: () => void;};type FeedbackOptions = { readonly flash: boolean; readonly animate: boolean }; function unavailable(error: unknown): boolean {  return (    error instanceof DBusError &&    ["ServiceUnknown", "NameHasNoOwner", "UnknownObject", "UnknownInterface", "UnknownMethod"].some(      (name) => error.type === `${DBUS}.Error.${name}`,    )  );} /** One connection per operation: portal registration and request ownership stay together. */export class LinuxCaptureConnection {  private readonly bus: MessageBus;  private readonly disconnected: Promise<never>;  private uniqueName = "";  private extensionVersion = 0;  private closed = false;  private feedbackTimer: ReturnType<typeof setTimeout> | undefined;   get feedbackAvailable() {    return this.extensionVersion === 2;  }   constructor(bus = sessionBus()) {    this.bus = bus;    this.disconnected = new Promise((_, reject) => {      bus.on("error", reject);    });    // A disconnect between calls must not become an unhandled rejection.    void this.disconnected.catch(() => undefined);  }   close() {    if (this.closed) return;    this.closed = true;    clearTimeout(this.feedbackTimer);    this.bus.disconnect();  }   private async wait<T>(pending: Promise<T>, timeoutMs = 5_000): Promise<T> {    let timer: ReturnType<typeof setTimeout> | undefined;    try {      return await Promise.race([        pending,        this.disconnected,        new Promise<never>((_, reject) => {          timer = setTimeout(() => reject(new Error("Snapshot timed out.")), timeoutMs);        }),      ]);    } finally {      clearTimeout(timer);    }  }   private async call(message: MessageLike) {    const reply = await this.wait(this.bus.call(new Message(message)));    if (!reply) throw new Error("Missing D-Bus reply.");    this.uniqueName = reply.destination;    return reply;  }   private async properties(destination: string, path: string, iface: string) {    const reply = await this.call({      destination,      path,      interface: "org.freedesktop.DBus.Properties",      member: "GetAll",      signature: "s",      body: [iface],    });    return reply.body[0] as unknown;  }   async backend(appId: string): Promise<LinuxCaptureBackend> {    if (isKdeCaptureSession()) {      const kde = await this.properties(        "org.kde.KWin.ScreenShot2",        "/org/kde/KWin/ScreenShot2",        "org.kde.KWin.ScreenShot2",      ).catch((error: unknown) => {        if (!unavailable(error)) throw error;        return undefined;      });      if (kde !== undefined && decodeKde(kde).Version.value >= 2) return "kde";    }    // Sandboxed apps already have an identity. Host apps register before any portal calls.    if (!process.env.FLATPAK_ID && !process.env.SNAP) {      await this.call({        destination: PORTAL,        path: PORTAL_PATH,        interface: "org.freedesktop.host.portal.Registry",        member: "Register",        signature: "sa{sv}",        body: [appId, {}],      }).catch((error: unknown) => {        if (!unavailable(error)) throw error;      });    }    const properties = await this.properties(PORTAL, PORTAL_PATH, SCREENSHOT).catch(      (error: unknown) => {        if (!unavailable(error)) throw error;        return undefined;      },    );    if (properties !== undefined) {      const parsed = decodeProperties(properties);      if (parsed.version.value >= 3 && ((parsed.AvailableTargets?.value ?? 0) & 8) !== 0) {        return "screenshot-portal";      }    }    if (!isGnomeCaptureSession(process.env)) return "picker";    const extension = await this.properties(EXTENSION, EXTENSION_PATH, EXTENSION).catch(      (error: unknown) => {        if (!unavailable(error)) throw error;        return undefined;      },    );    if (extension !== undefined) {      const parsed = decodeExtension(extension);      this.extensionVersion = parsed.Version.value;      if (this.extensionVersion === 1 || this.extensionVersion === 2) return "gnome-extension";    }    return "picker";  }   async capturePortal(): Promise<LinuxWindowSnapshot> {    const owner = await this.call({      destination: DBUS,      path: DBUS_PATH,      interface: DBUS,      member: "GetNameOwner",      signature: "s",      body: [PORTAL],    });    const sender = decodeString(owner.body[0]);    const token = `t3_${NodeCrypto.randomUUID().replaceAll("-", "")}`;    const namespace = `${PORTAL_PATH}/request/${this.uniqueName.slice(1).replaceAll(".", "_")}/`;    let handle = namespace + token;    let completed = false;    // Subscribe before Screenshot: the response may precede its method reply.    const responses = new Map<string, unknown>();    let deliver: ((body: unknown) => void) | undefined;    const listener = (message: Message) => {      if (        message.type !== MessageType.SIGNAL ||        message.sender !== sender ||        message.interface !== REQUEST ||        message.member !== "Response" ||        !message.path.startsWith(namespace)      )        return;      if (deliver && message.path === handle) deliver(message.body);      else if (responses.size < 8) responses.set(message.path, message.body);    };    this.bus.on("message", listener);    try {      await this.call({        destination: DBUS,        path: DBUS_PATH,        interface: DBUS,        member: "AddMatch",        signature: "s",        body: [          `type='signal',sender='${sender}',interface='${REQUEST}',member='Response',path_namespace='${namespace.slice(0, -1)}'`,        ],      });      const reply = await this.call({        destination: sender,        path: PORTAL_PATH,        interface: SCREENSHOT,        member: "Screenshot",        signature: "sa{sv}",        body: [          "",          {            handle_token: new Variant("s", token),            interactive: new Variant("b", false),            modal: new Variant("b", false),            target: new Variant("u", 8),          },        ],      });      handle = decodeString(reply.body[0]);      if (!handle.startsWith(namespace)) throw new Error("Invalid screenshot request handle.");      const body = await this.wait(        new Promise<unknown>((resolve) => {          deliver = resolve;          if (responses.has(handle)) resolve(responses.get(handle));        }),        120_000,      );      const [status, results] = decodeResponse(body);      completed = true;      if (status === 1) throw new Error("Snapshot was cancelled.");      if (status !== 0) throw new Error("Your desktop did not allow the snapshot.");      const uri = decodeUri(results.uri).value;      return { png: await readPortalPng(uri) };    } finally {      this.bus.removeListener("message", listener);      if (!completed) {        this.bus.send(          new Message({            destination: sender,            path: handle,            interface: REQUEST,            member: "Close",            flags: MessageFlag.NO_REPLY_EXPECTED,          }),        );      }      // Closing this dedicated connection also removes the signal match.    }  }   async captureExtension(appId: string, options?: FeedbackOptions): Promise<LinuxWindowSnapshot> {    const result = await this.wait(      this.bus.requestName(`${appId}.SnapShot`, NameFlag.DO_NOT_QUEUE),    );    if (result !== RequestNameReply.PRIMARY_OWNER) {      throw new Error("Another T3 Code instance is capturing a window. Try again.");    }    const withFeedback = this.feedbackAvailable && options !== undefined;    const reply = await this.call({      destination: EXTENSION,      path: EXTENSION_PATH,      interface: EXTENSION,      member: withFeedback ? "CaptureWithFeedback" : "Capture",      ...(withFeedback ? { signature: "bb", body: [options.flash, options.animate] } : {}),    });    const bytes: unknown = reply.body[0];    if (!(bytes instanceof Uint8Array)) throw new Error("Invalid extension screenshot.");    const window = decodeWindow(reply.body[1]);    const png = resizeLinuxCapture(Buffer.from(bytes));    if (!withFeedback) return { png, window };    const animationStarted = decodeBoolean(reply.body[2]);    // Keep the same authenticated sender alive through activation and the compositor flight.    this.feedbackTimer = setTimeout(() => this.close(), 15_000);    let flight: Promise<void> | undefined;    const feedback: LinuxCaptureFeedback = {      animationStarted,      activate: async (title) => {        await this.feedbackCall("Activate", "s", [title]);      },      animateTo: (frame) => {        flight ??= this.feedbackCall("Animate", "dddd", [          frame.x,          frame.y,          frame.width,          frame.height,        ]);        return flight;      },      complete: async () => {        try {          await flight;        } finally {          this.close();        }      },      close: () => this.close(),    };    return { png, window, feedback };  }   private async feedbackCall(member: string, signature: string, body: unknown[]): Promise<void> {    if (this.closed) return;    await this.call({      destination: EXTENSION,      path: EXTENSION_PATH,      interface: EXTENSION,      member,      signature,      body,    });  }} export async function getLinuxCaptureSupport(appId: string) {  if (isHyprlandCaptureSession())    return { linuxBackend: "hyprland" as const, linuxFeedbackAvailable: false };  const { niriSocketPath, checkNiriCaptureSupport } = await import("./NiriSnapShot.ts");  const niri = niriSocketPath();  if (niri) {    await checkNiriCaptureSupport(niri);    return { linuxBackend: "niri" as const, linuxFeedbackAvailable: false };  }  const connection = new LinuxCaptureConnection();  try {    const linuxBackend = await connection.backend(appId);    return { linuxBackend, linuxFeedbackAvailable: connection.feedbackAvailable };  } finally {    connection.close();  }} /** Undefined means capability missing, not denied: only that case may open the picker. */export async function captureLinuxWindow(  appId: string,  options?: FeedbackOptions,  kdePaths?: KdeCapturePaths,  hyprlandPaths?: HyprlandCapturePaths,): Promise<LinuxWindowSnapshot | undefined> {  if (isHyprlandCaptureSession()) {    if (!hyprlandPaths) throw new Error("Hyprland capture setup is unavailable in this build.");    const { captureHyprlandWindow } = await import("./HyprlandSnapShot.ts");    return captureHyprlandWindow(hyprlandPaths, options);  }  const { niriSocketPath, captureNiriWindow } = await import("./NiriSnapShot.ts");  const niri = niriSocketPath();  if (niri) return captureNiriWindow(niri);  const connection = new LinuxCaptureConnection();  let retained = false;  try {    switch (await connection.backend(appId)) {      case "kde": {        if (!kdePaths) throw new Error("KDE capture setup is unavailable in this build.");        const { captureKdeWindow } = await import("./KdeSnapShot.ts");        return await captureKdeWindow(kdePaths, options);      }      case "screenshot-portal":        return await connection.capturePortal();      case "gnome-extension": {        const snapshot = await connection.captureExtension(appId, options);        retained = snapshot.feedback !== undefined;        return snapshot;      }      case "picker":        return undefined;    }  } finally {    if (!retained) connection.close();  }}