@chatroomcp/chatroom 0.1.7 → 0.2.0

package/dist/plugins/computer/computer-native-host.js

@@ -0,0 +1,245 @@
+import { randomUUID } from "node:crypto";
+import { spawn } from "node:child_process";
+import { chmodSync, existsSync, rmSync } from "node:fs";
+import { createServer } from "node:net";
+import { createInterface } from "node:readline";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { ChatRoomError } from "../../core/errors/chatroom-error.js";
+import { COMPUTER_NATIVE_PROTOCOL_VERSION, nativeError, parseNativeEnvelope, } from "./computer-protocol.js";
+export class ComputerNativeHost {
+    child = null;
+    socket = null;
+    socketServer = null;
+    socketPath = null;
+    lines = null;
+    starting = null;
+    pending = new Map();
+    sequence = 0;
+    get platform() {
+        if (process.platform === "darwin")
+            return "macos";
+        if (process.platform === "win32")
+            return "windows";
+        return "unsupported";
+    }
+    get idle() {
+        return this.pending.size === 0;
+    }
+    async request(method, params) {
+        await this.ensureStarted();
+        const id = `computer_${++this.sequence}`;
+        const timeoutMs = requestTimeoutMs(method);
+        const promise = new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pending.delete(id);
+                const error = new ChatRoomError("INTERNAL", `Computer helper ${method} request timed out after ${timeoutMs} ms`);
+                reject(error);
+                this.reset(error);
+            }, timeoutMs);
+            timer.unref();
+            this.pending.set(id, { resolve, reject, timer });
+        });
+        const line = `${JSON.stringify({
+            protocol: COMPUTER_NATIVE_PROTOCOL_VERSION,
+            id,
+            method,
+            params,
+        })}\n`;
+        if (this.platform === "macos")
+            this.socket.write(line);
+        else
+            this.child.stdin.write(line);
+        return promise;
+    }
+    restart(reason = "Computer helper restarting") {
+        this.reset(new Error(reason));
+    }
+    async dispose() {
+        this.reset(new Error("Computer helper stopped"));
+    }
+    async ensureStarted() {
+        if (this.platform === "macos" && this.socket && !this.socket.destroyed)
+            return;
+        if (this.platform === "windows" && this.child && !this.child.killed)
+            return;
+        if (this.starting)
+            return this.starting;
+        this.starting =
+            this.platform === "macos"
+                ? this.startMacHelper()
+                : this.platform === "windows"
+                    ? this.startWindowsHelper()
+                    : Promise.reject(new ChatRoomError("UNSUPPORTED", "Computer Use is supported only on macOS and Windows"));
+        try {
+            await this.starting;
+        }
+        finally {
+            this.starting = null;
+        }
+    }
+    async startMacHelper() {
+        const app = macHelperAppPath();
+        if (!app)
+            throw new ChatRoomError("UNSUPPORTED", "macOS Computer helper is missing");
+        this.cleanupSocketPath();
+        const socketPath = path.join("/tmp", `chatroom-c-${process.pid}-${randomUUID().slice(0, 8)}.sock`);
+        this.socketPath = socketPath;
+        await new Promise((resolve, reject) => {
+            const server = createServer();
+            this.socketServer = server;
+            let settled = false;
+            const timer = setTimeout(() => fail(new Error("Computer helper connection timed out")), 10_000);
+            timer.unref();
+            const cleanupServer = () => {
+                clearTimeout(timer);
+                if (this.socketServer === server)
+                    this.socketServer = null;
+                server.close();
+            };
+            const fail = (error) => {
+                if (settled)
+                    return;
+                settled = true;
+                cleanupServer();
+                this.cleanupSocketPath();
+                reject(error);
+            };
+            server.once("error", fail);
+            server.once("connection", (socket) => {
+                if (settled) {
+                    socket.destroy();
+                    return;
+                }
+                settled = true;
+                server.removeListener("error", fail);
+                cleanupServer();
+                this.attachSocket(socket);
+                resolve();
+            });
+            server.listen(socketPath, () => {
+                chmodSync(socketPath, 0o600);
+                const launcher = spawn("/usr/bin/open", ["-n", "-g", app, "--args", "--connect", socketPath], { stdio: "ignore" });
+                launcher.once("error", fail);
+            });
+        });
+    }
+    attachSocket(socket) {
+        this.socket = socket;
+        this.lines = createInterface({ input: socket });
+        this.lines.on("line", (line) => this.handleLine(line));
+        socket.once("error", (error) => this.failTransport(socket, error));
+        socket.once("close", () => this.failTransport(socket, new Error("Computer helper exited")));
+    }
+    async startWindowsHelper() {
+        const executable = windowsHelperPath();
+        if (!executable)
+            throw new ChatRoomError("UNSUPPORTED", "Windows Computer helper is missing");
+        const child = spawn(executable, [], {
+            stdio: ["pipe", "pipe", "pipe"],
+            windowsHide: true,
+        });
+        this.child = child;
+        this.lines = createInterface({ input: child.stdout });
+        this.lines.on("line", (line) => this.handleLine(line));
+        child.stderr.on("data", (chunk) => console.error("[computer-helper]", String(chunk).trimEnd()));
+        child.once("error", (error) => this.failTransport(child, error));
+        child.once("exit", () => this.failTransport(child, new Error("Computer helper exited")));
+    }
+    failTransport(transport, error) {
+        const isCurrentSocket = transport === this.socket;
+        const isCurrentChild = transport === this.child;
+        if (!isCurrentSocket && !isCurrentChild)
+            return;
+        if (isCurrentSocket)
+            this.socket = null;
+        if (isCurrentChild)
+            this.child = null;
+        this.lines?.close();
+        this.lines = null;
+        this.cleanupSocketPath();
+        this.rejectPending(error);
+    }
+    reset(error) {
+        this.lines?.close();
+        this.lines = null;
+        this.socket?.destroy();
+        this.socket = null;
+        this.socketServer?.close();
+        this.socketServer = null;
+        this.child?.kill();
+        this.child = null;
+        this.cleanupSocketPath();
+        this.rejectPending(error);
+    }
+    rejectPending(error) {
+        for (const item of this.pending.values()) {
+            clearTimeout(item.timer);
+            item.reject(error);
+        }
+        this.pending.clear();
+    }
+    cleanupSocketPath() {
+        if (!this.socketPath)
+            return;
+        rmSync(this.socketPath, { force: true });
+        this.socketPath = null;
+    }
+    handleLine(line) {
+        let raw;
+        try {
+            raw = JSON.parse(line);
+        }
+        catch {
+            return;
+        }
+        const rawId = raw && typeof raw === "object" && "id" in raw
+            ? raw.id
+            : undefined;
+        if (typeof rawId !== "string")
+            return;
+        const pending = this.pending.get(rawId);
+        if (!pending)
+            return;
+        let message;
+        try {
+            message = parseNativeEnvelope(raw);
+        }
+        catch (error) {
+            this.pending.delete(rawId);
+            clearTimeout(pending.timer);
+            pending.reject(error);
+            return;
+        }
+        this.pending.delete(message.id);
+        clearTimeout(pending.timer);
+        if (message.error)
+            pending.reject(nativeError(message.error));
+        else
+            pending.resolve(message.result);
+    }
+}
+function requestTimeoutMs(method) {
+    switch (method) {
+        case "status":
+            return 5_000;
+        case "snapshot":
+            return 15_000;
+        case "requestPermission":
+            return 30_000;
+        case "action":
+            return 60_000;
+    }
+}
+function projectRoot() {
+    const current = fileURLToPath(import.meta.url);
+    return path.resolve(path.dirname(current), "../../..");
+}
+function macHelperAppPath() {
+    const app = path.join(projectRoot(), "dist", "native", "macos", "ChatRoomComputerHelper.app");
+    return existsSync(app) ? app : null;
+}
+function windowsHelperPath() {
+    const executable = path.join(projectRoot(), "dist", "native", "windows", "chatroom-computer-helper.exe");
+    return existsSync(executable) ? executable : null;
+}

package/dist/plugins/computer/computer-protocol.d.ts

@@ -0,0 +1,21 @@
+import { ChatRoomError } from "../../core/errors/chatroom-error.js";
+import type { ComputerActionResult, ComputerSnapshot, ComputerStatus } from "./types.js";
+export declare const COMPUTER_NATIVE_PROTOCOL_VERSION = 1;
+export type ComputerNativeMethod = "status" | "requestPermission" | "snapshot" | "action";
+export interface ComputerNativeResultMap {
+    status: Omit<ComputerStatus, "settings">;
+    requestPermission: Omit<ComputerStatus, "settings">;
+    snapshot: ComputerSnapshot;
+    action: ComputerActionResult;
+}
+export interface ComputerNativeError {
+    code?: string;
+    message: string;
+}
+export declare function parseNativeEnvelope(value: unknown): {
+    id: string;
+    result?: unknown;
+    error?: ComputerNativeError;
+};
+export declare function parseNativeResult<M extends ComputerNativeMethod>(method: M, value: unknown): ComputerNativeResultMap[M];
+export declare function nativeError(error: ComputerNativeError): ChatRoomError;

package/dist/plugins/computer/computer-protocol.js

@@ -0,0 +1,72 @@
+import { z } from "zod";
+import { ChatRoomError, } from "../../core/errors/chatroom-error.js";
+import { computerActionResultSchema, computerNativeStatusSchema, computerSnapshotSchema, } from "./computer-schemas.js";
+export const COMPUTER_NATIVE_PROTOCOL_VERSION = 1;
+const responseEnvelopeSchema = z
+    .object({
+    protocol: z.literal(COMPUTER_NATIVE_PROTOCOL_VERSION).optional(),
+    id: z.string(),
+    result: z.unknown().optional(),
+    error: z
+        .object({
+        code: z.string().optional(),
+        message: z.string(),
+    })
+        .optional(),
+})
+    .refine((value) => value.result !== undefined || value.error !== undefined, {
+    message: "Native response must contain result or error",
+});
+export function parseNativeEnvelope(value) {
+    const parsed = responseEnvelopeSchema.safeParse(value);
+    if (!parsed.success) {
+        throw new ChatRoomError("INTERNAL", "Computer helper returned an invalid protocol response", { issues: parsed.error.issues });
+    }
+    return {
+        id: parsed.data.id,
+        ...(parsed.data.result === undefined ? {} : { result: parsed.data.result }),
+        ...(parsed.data.error === undefined
+            ? {}
+            : {
+                error: {
+                    message: parsed.data.error.message,
+                    ...(parsed.data.error.code === undefined
+                        ? {}
+                        : { code: parsed.data.error.code }),
+                },
+            }),
+    };
+}
+export function parseNativeResult(method, value) {
+    const schema = method === "status" || method === "requestPermission"
+        ? computerNativeStatusSchema
+        : method === "snapshot"
+            ? computerSnapshotSchema
+            : computerActionResultSchema;
+    const parsed = schema.safeParse(value);
+    if (!parsed.success) {
+        throw new ChatRoomError("INTERNAL", `Computer helper returned an invalid ${method} result`, { issues: parsed.error.issues });
+    }
+    return parsed.data;
+}
+export function nativeError(error) {
+    return new ChatRoomError(nativeErrorCode(error.code), error.message, {
+        nativeCode: error.code ?? null,
+    });
+}
+function nativeErrorCode(code) {
+    switch (code) {
+        case "invalid_request":
+            return "INVALID_INPUT";
+        case "not_found":
+            return "NOT_FOUND";
+        case "permission_required":
+            return "FORBIDDEN";
+        case "stale_snapshot":
+            return "CONFLICT";
+        case "unsupported":
+            return "UNSUPPORTED";
+        default:
+            return "INTERNAL";
+    }
+}

package/dist/plugins/computer/computer-schemas.d.ts

@@ -0,0 +1,317 @@
+import { z } from "zod";
+export declare const computerPermissionStateSchema: z.ZodEnum<{
+    granted: "granted";
+    denied: "denied";
+    unknown: "unknown";
+    "not-required": "not-required";
+}>;
+export declare const computerDisplaySchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    width: z.ZodNumber;
+    height: z.ZodNumber;
+    scale: z.ZodNumber;
+    primary: z.ZodBoolean;
+}, z.core.$strip>;
+export declare const computerElementSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    role: z.ZodString;
+    name: z.ZodNullable<z.ZodString>;
+    value: z.ZodNullable<z.ZodString>;
+    enabled: z.ZodBoolean;
+    focused: z.ZodBoolean;
+    selected: z.ZodBoolean;
+    sensitive: z.ZodBoolean;
+    bounds: z.ZodNullable<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+    actions: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export declare const computerScreenshotSchema: z.ZodObject<{
+    mimeType: z.ZodEnum<{
+        "image/jpeg": "image/jpeg";
+        "image/png": "image/png";
+    }>;
+    data: z.ZodString;
+}, z.core.$strip>;
+export declare const computerNativeStatusSchema: z.ZodObject<{
+    platform: z.ZodEnum<{
+        macos: "macos";
+        windows: "windows";
+        unsupported: "unsupported";
+    }>;
+    helper: z.ZodEnum<{
+        running: "running";
+        stopped: "stopped";
+        unavailable: "unavailable";
+    }>;
+    permissions: z.ZodObject<{
+        accessibility: z.ZodEnum<{
+            granted: "granted";
+            denied: "denied";
+            unknown: "unknown";
+            "not-required": "not-required";
+        }>;
+        screenRecording: z.ZodEnum<{
+            granted: "granted";
+            denied: "denied";
+            unknown: "unknown";
+            "not-required": "not-required";
+        }>;
+    }, z.core.$strip>;
+    displays: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        width: z.ZodNumber;
+        height: z.ZodNumber;
+        scale: z.ZodNumber;
+        primary: z.ZodBoolean;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const computerSnapshotSchema: z.ZodObject<{
+    snapshotId: z.ZodString;
+    revision: z.ZodNumber;
+    display: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        width: z.ZodNumber;
+        height: z.ZodNumber;
+        scale: z.ZodNumber;
+        primary: z.ZodBoolean;
+    }, z.core.$strip>>;
+    activeApp: z.ZodNullable<z.ZodString>;
+    activeWindow: z.ZodNullable<z.ZodString>;
+    cursor: z.ZodNullable<z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+    }, z.core.$strip>>;
+    elements: z.ZodArray<z.ZodObject<{
+        id: z.ZodNumber;
+        role: z.ZodString;
+        name: z.ZodNullable<z.ZodString>;
+        value: z.ZodNullable<z.ZodString>;
+        enabled: z.ZodBoolean;
+        focused: z.ZodBoolean;
+        selected: z.ZodBoolean;
+        sensitive: z.ZodBoolean;
+        bounds: z.ZodNullable<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+        actions: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>;
+    screenshot: z.ZodOptional<z.ZodObject<{
+        mimeType: z.ZodEnum<{
+            "image/jpeg": "image/jpeg";
+            "image/png": "image/png";
+        }>;
+        data: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const computerSnapshotMetadataSchema: z.ZodObject<{
+    display: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        width: z.ZodNumber;
+        height: z.ZodNumber;
+        scale: z.ZodNumber;
+        primary: z.ZodBoolean;
+    }, z.core.$strip>>;
+    snapshotId: z.ZodString;
+    revision: z.ZodNumber;
+    activeApp: z.ZodNullable<z.ZodString>;
+    activeWindow: z.ZodNullable<z.ZodString>;
+    cursor: z.ZodNullable<z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+    }, z.core.$strip>>;
+    elements: z.ZodArray<z.ZodObject<{
+        id: z.ZodNumber;
+        role: z.ZodString;
+        name: z.ZodNullable<z.ZodString>;
+        value: z.ZodNullable<z.ZodString>;
+        enabled: z.ZodBoolean;
+        focused: z.ZodBoolean;
+        selected: z.ZodBoolean;
+        sensitive: z.ZodBoolean;
+        bounds: z.ZodNullable<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+        actions: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const computerActionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"move">;
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"click">;
+    x: z.ZodOptional<z.ZodNumber>;
+    y: z.ZodOptional<z.ZodNumber>;
+    elementId: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"double_click">;
+    x: z.ZodOptional<z.ZodNumber>;
+    y: z.ZodOptional<z.ZodNumber>;
+    elementId: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"right_click">;
+    x: z.ZodOptional<z.ZodNumber>;
+    y: z.ZodOptional<z.ZodNumber>;
+    elementId: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"drag">;
+    from: z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+    }, z.core.$strip>;
+    to: z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+    }, z.core.$strip>;
+    durationMs: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"scroll">;
+    deltaX: z.ZodOptional<z.ZodNumber>;
+    deltaY: z.ZodNumber;
+    elementId: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"keypress">;
+    keys: z.ZodArray<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"type_text">;
+    text: z.ZodString;
+    elementId: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"invoke">;
+    elementId: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"set_value">;
+    elementId: z.ZodNumber;
+    value: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"select_text">;
+    elementId: z.ZodNumber;
+    start: z.ZodNumber;
+    length: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"activate_app">;
+    app: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"activate_window">;
+    elementId: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"move_window">;
+    elementId: z.ZodNumber;
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"resize_window">;
+    elementId: z.ZodNumber;
+    width: z.ZodNumber;
+    height: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"wait">;
+    ms: z.ZodNumber;
+}, z.core.$strip>], "type">;
+export declare const computerActionResultSchema: z.ZodObject<{
+    success: z.ZodLiteral<true>;
+    revision: z.ZodNumber;
+    snapshot: z.ZodOptional<z.ZodObject<{
+        snapshotId: z.ZodString;
+        revision: z.ZodNumber;
+        display: z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            width: z.ZodNumber;
+            height: z.ZodNumber;
+            scale: z.ZodNumber;
+            primary: z.ZodBoolean;
+        }, z.core.$strip>>;
+        activeApp: z.ZodNullable<z.ZodString>;
+        activeWindow: z.ZodNullable<z.ZodString>;
+        cursor: z.ZodNullable<z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+        }, z.core.$strip>>;
+        elements: z.ZodArray<z.ZodObject<{
+            id: z.ZodNumber;
+            role: z.ZodString;
+            name: z.ZodNullable<z.ZodString>;
+            value: z.ZodNullable<z.ZodString>;
+            enabled: z.ZodBoolean;
+            focused: z.ZodBoolean;
+            selected: z.ZodBoolean;
+            sensitive: z.ZodBoolean;
+            bounds: z.ZodNullable<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+            actions: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>>;
+        screenshot: z.ZodOptional<z.ZodObject<{
+            mimeType: z.ZodEnum<{
+                "image/jpeg": "image/jpeg";
+                "image/png": "image/png";
+            }>;
+            data: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    executionMode: z.ZodEnum<{
+        semantic: "semantic";
+        background: "background";
+        foreground: "foreground";
+        mixed: "mixed";
+    }>;
+    focusChanged: z.ZodBoolean;
+}, z.core.$strip>;
+export declare const computerActionMetadataSchema: z.ZodObject<{
+    success: z.ZodLiteral<true>;
+    revision: z.ZodNumber;
+    executionMode: z.ZodEnum<{
+        semantic: "semantic";
+        background: "background";
+        foreground: "foreground";
+        mixed: "mixed";
+    }>;
+    focusChanged: z.ZodBoolean;
+    snapshot: z.ZodOptional<z.ZodObject<{
+        display: z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            width: z.ZodNumber;
+            height: z.ZodNumber;
+            scale: z.ZodNumber;
+            primary: z.ZodBoolean;
+        }, z.core.$strip>>;
+        snapshotId: z.ZodString;
+        revision: z.ZodNumber;
+        activeApp: z.ZodNullable<z.ZodString>;
+        activeWindow: z.ZodNullable<z.ZodString>;
+        cursor: z.ZodNullable<z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+        }, z.core.$strip>>;
+        elements: z.ZodArray<z.ZodObject<{
+            id: z.ZodNumber;
+            role: z.ZodString;
+            name: z.ZodNullable<z.ZodString>;
+            value: z.ZodNullable<z.ZodString>;
+            enabled: z.ZodBoolean;
+            focused: z.ZodBoolean;
+            selected: z.ZodBoolean;
+            sensitive: z.ZodBoolean;
+            bounds: z.ZodNullable<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+            actions: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const computerSnapshotTargetSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"desktop">;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"display">;
+    displayId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"app">;
+    app: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"window">;
+    elementId: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"region">;
+    displayId: z.ZodOptional<z.ZodString>;
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+    width: z.ZodNumber;
+    height: z.ZodNumber;
+}, z.core.$strip>], "type">;