@zhanguym/chatroom 1.0.0

package/dist/plugins/cloud/types.js

@@ -0,0 +1,60 @@
+import { z } from "zod";
+export const CLOUD_SERVICES = ["remote_mcp", "remote_web"];
+export const CLOUD_HTTP_URL_SCHEMA = z
+    .string()
+    .url()
+    .refine((value) => {
+    const protocol = new URL(value).protocol;
+    return protocol === "http:" || protocol === "https:";
+}, "URL must use HTTP or HTTPS");
+export const CLOUD_WEBSOCKET_URL_SCHEMA = z
+    .string()
+    .url()
+    .refine((value) => {
+    const protocol = new URL(value).protocol;
+    return protocol === "ws:" || protocol === "wss:";
+}, "URL must use WS or WSS");
+export const CLOUD_SERVICE_SCHEMA = z.enum(CLOUD_SERVICES);
+const PUBLIC_SERVICE_TO_CLOUD_SERVICE = {
+    mcp: "remote_mcp",
+    web: "remote_web",
+};
+export const CLOUD_DESIRED_SERVICES_SCHEMA = z
+    .object({ remote_mcp: z.boolean(), remote_web: z.boolean() })
+    .strict();
+export function cloudServiceForPublicService(service) {
+    return PUBLIC_SERVICE_TO_CLOUD_SERVICE[service];
+}
+export const CLOUD_ENTITLEMENT_SCHEMA = z
+    .object({
+    service: CLOUD_SERVICE_SCHEMA,
+    status: z.literal("active"),
+    sourceProvider: z.string().min(1),
+    sourceId: z.string().min(1),
+    validUntil: z.string().datetime().nullable(),
+})
+    .strict();
+export const CLOUD_LEASE_SCHEMA = z
+    .object({
+    token: z.string().min(1),
+    expiresAt: z.string().datetime(),
+    tunnelUrl: CLOUD_WEBSOCKET_URL_SCHEMA,
+    mcpBaseUrl: CLOUD_HTTP_URL_SCHEMA.nullable(),
+    webBaseUrl: CLOUD_HTTP_URL_SCHEMA.nullable(),
+    services: z.array(CLOUD_SERVICE_SCHEMA),
+})
+    .strict()
+    .superRefine((value, context) => {
+    if (value.services.includes("remote_mcp") && !value.mcpBaseUrl)
+        context.addIssue({
+            code: "custom",
+            path: ["mcpBaseUrl"],
+            message: "remote_mcp lease requires mcpBaseUrl",
+        });
+    if (value.services.includes("remote_web") && !value.webBaseUrl)
+        context.addIssue({
+            code: "custom",
+            path: ["webBaseUrl"],
+            message: "remote_web lease requires webBaseUrl",
+        });
+});

package/dist/plugins/computer/audit.d.ts

@@ -0,0 +1,34 @@
+import type { ComputerAction, ComputerActionResult, ComputerSnapshot } from "./types.js";
+export declare function auditComputerActions(input: {
+    snapshotId?: string;
+    actions: ComputerAction[];
+    observeAfter?: boolean;
+}): {
+    snapshotId: string | null;
+    observeAfter: boolean;
+    actions: unknown[];
+};
+export declare function auditSnapshotOutput(value: ComputerSnapshot): {
+    snapshotId: string;
+    revision: number;
+    display: import("./types.js").ComputerDisplay | null;
+    activeApp: string | null;
+    activeWindow: string | null;
+    elementCount: number;
+    screenshot: boolean;
+};
+export declare function auditActionOutput(value: ComputerActionResult): {
+    success: true;
+    revision: number;
+    executionMode: "semantic" | "background" | "foreground" | "mixed";
+    focusChanged: boolean;
+    snapshot: {
+        snapshotId: string;
+        revision: number;
+        display: import("./types.js").ComputerDisplay | null;
+        activeApp: string | null;
+        activeWindow: string | null;
+        elementCount: number;
+        screenshot: boolean;
+    } | null;
+};

package/dist/plugins/computer/audit.js

@@ -0,0 +1,42 @@
+export function auditComputerActions(input) {
+    return {
+        snapshotId: input.snapshotId ?? null,
+        observeAfter: input.observeAfter ?? true,
+        actions: input.actions.map((action) => sanitizeAction(action)),
+    };
+}
+function sanitizeAction(action) {
+    if (action.type === "type_text")
+        return {
+            type: action.type,
+            characters: action.text.length,
+            elementId: action.elementId ?? null,
+        };
+    if (action.type === "set_value")
+        return {
+            type: action.type,
+            characters: action.value.length,
+            elementId: action.elementId,
+        };
+    return action;
+}
+export function auditSnapshotOutput(value) {
+    return {
+        snapshotId: value.snapshotId,
+        revision: value.revision,
+        display: value.display,
+        activeApp: value.activeApp,
+        activeWindow: value.activeWindow,
+        elementCount: value.elements.length,
+        screenshot: Boolean(value.screenshot),
+    };
+}
+export function auditActionOutput(value) {
+    return {
+        success: value.success,
+        revision: value.revision,
+        executionMode: value.executionMode,
+        focusChanged: value.focusChanged,
+        snapshot: value.snapshot ? auditSnapshotOutput(value.snapshot) : null,
+    };
+}

package/dist/plugins/computer/computer-native-backend.d.ts

@@ -0,0 +1,11 @@
+import type { ComputerActionRequest, ComputerActionResult, ComputerBackend, ComputerPermission, ComputerSnapshot, ComputerSnapshotRequest, ComputerStatus } from "./types.js";
+export declare class NativeComputerBackend implements ComputerBackend {
+    private readonly host;
+    private readonly restartWhenGranted;
+    status(): Promise<Omit<ComputerStatus, "settings">>;
+    requestPermission(permission: ComputerPermission): Promise<Omit<ComputerStatus, "settings">>;
+    snapshot(request: ComputerSnapshotRequest, revision: number): Promise<ComputerSnapshot>;
+    action(request: ComputerActionRequest, revision: number): Promise<ComputerActionResult>;
+    dispose(): Promise<void>;
+    private readStatus;
+}

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

@@ -0,0 +1,58 @@
+import { ChatRoomError } from "#core/errors/chatroom-error";
+import { ComputerNativeHost } from "./computer-native-host.js";
+import { parseNativeResult } from "./computer-protocol.js";
+export class NativeComputerBackend {
+    host = new ComputerNativeHost();
+    restartWhenGranted = new Set();
+    async status() {
+        const value = await this.readStatus().catch(() => ({
+            platform: this.host.platform,
+            helper: "unavailable",
+            permissions: {
+                accessibility: "unknown",
+                screenRecording: "unknown",
+            },
+            displays: [],
+        }));
+        if (this.host.platform !== "macos" || value.helper !== "running")
+            return value;
+        const newlyGranted = [...this.restartWhenGranted].filter((permission) => value.permissions[permission] === "granted");
+        if (!newlyGranted.length || !this.host.idle)
+            return value;
+        for (const permission of newlyGranted)
+            this.restartWhenGranted.delete(permission);
+        this.host.restart("Computer helper restarting after permission change");
+        return this.readStatus();
+    }
+    async requestPermission(permission) {
+        if (this.host.platform !== "macos")
+            throw new ChatRoomError("UNSUPPORTED", "Permission requests are currently supported only on macOS");
+        const result = await this.host.request("requestPermission", { permission });
+        const value = parseNativeResult("requestPermission", result);
+        if (value.permissions[permission] !== "granted") {
+            this.restartWhenGranted.add(permission);
+            return value;
+        }
+        this.restartWhenGranted.delete(permission);
+        this.host.restart("Computer helper restarting after permission change");
+        return this.readStatus();
+    }
+    async snapshot(request, revision) {
+        const result = await this.host.request("snapshot", {
+            ...request,
+            revision,
+        });
+        return parseNativeResult("snapshot", result);
+    }
+    async action(request, revision) {
+        const result = await this.host.request("action", { ...request, revision });
+        return parseNativeResult("action", result);
+    }
+    async dispose() {
+        this.restartWhenGranted.clear();
+        await this.host.dispose();
+    }
+    async readStatus() {
+        return parseNativeResult("status", await this.host.request("status", {}));
+    }
+}

package/dist/plugins/computer/computer-native-host.d.ts

@@ -0,0 +1,30 @@
+import { type ComputerNativeMethod } from "./computer-protocol.js";
+import type { ComputerPlatform } from "./types.js";
+export declare class ComputerNativeHost {
+    private child;
+    private socket;
+    private socketServer;
+    private socketPath;
+    private lines;
+    private starting;
+    private cancelStarting;
+    private readonly pending;
+    private sequence;
+    private generation;
+    get platform(): ComputerPlatform;
+    get idle(): boolean;
+    request(method: ComputerNativeMethod, params: unknown): Promise<unknown>;
+    restart(reason?: string): void;
+    dispose(): Promise<void>;
+    private ensureStarted;
+    private startHelper;
+    private startMacHelper;
+    private attachSocket;
+    private startPipeHelper;
+    private failTransport;
+    private reset;
+    private rejectRequest;
+    private rejectPending;
+    private cleanupSocketPath;
+    private handleLine;
+}

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

@@ -0,0 +1,411 @@
+import { randomUUID } from "node:crypto";
+import { spawn, spawnSync, } 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";
+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;
+    cancelStarting = null;
+    pending = new Map();
+    sequence = 0;
+    generation = 0;
+    get platform() {
+        if (process.platform === "darwin")
+            return "macos";
+        if (process.platform === "win32")
+            return "windows";
+        if (process.platform === "linux")
+            return "linux";
+        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`;
+        const transportError = new ChatRoomError("INTERNAL", "Computer helper transport is unavailable");
+        if (this.platform === "macos") {
+            const socket = this.socket;
+            if (!socket || socket.destroyed)
+                this.rejectRequest(id, transportError);
+            else
+                socket.write(line);
+        }
+        else {
+            const child = this.child;
+            if (!child || child.killed || child.stdin.destroyed)
+                this.rejectRequest(id, transportError);
+            else
+                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() {
+        const platform = this.platform;
+        if (platform === "macos" && this.socket && !this.socket.destroyed)
+            return;
+        if ((platform === "windows" || platform === "linux") &&
+            this.child &&
+            !this.child.killed)
+            return;
+        if (this.starting)
+            return this.starting;
+        const generation = this.generation;
+        const starting = this.startHelper(platform, generation);
+        this.starting = starting;
+        try {
+            await starting;
+            if (generation !== this.generation)
+                throw new Error("Computer helper start was superseded");
+        }
+        finally {
+            if (this.starting === starting)
+                this.starting = null;
+            if (generation === this.generation)
+                this.cancelStarting = null;
+        }
+    }
+    startHelper(platform, generation) {
+        switch (platform) {
+            case "macos":
+                return this.startMacHelper(generation);
+            case "windows":
+                return this.startPipeHelper(windowsHelperPath(), "Windows", process.env, generation);
+            case "linux":
+                return this.startPipeHelper(linuxHelperPath(), "Linux X11", linuxDesktopEnvironment(), generation);
+            case "unsupported":
+                return Promise.reject(new ChatRoomError("UNSUPPORTED", "Computer Use is supported only on macOS, Windows, and Linux X11"));
+        }
+    }
+    async startMacHelper(generation) {
+        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;
+                if (this.cancelStarting === fail)
+                    this.cancelStarting = null;
+                if (server.listening)
+                    server.close();
+            };
+            const fail = (error) => {
+                if (settled)
+                    return;
+                settled = true;
+                cleanupServer();
+                this.cleanupSocketPath(socketPath);
+                reject(error);
+            };
+            this.cancelStarting = fail;
+            server.once("error", fail);
+            server.once("connection", (socket) => {
+                if (settled || generation !== this.generation) {
+                    socket.destroy();
+                    if (!settled)
+                        fail(new Error("Computer helper start was superseded"));
+                    return;
+                }
+                settled = true;
+                server.removeListener("error", fail);
+                cleanupServer();
+                this.attachSocket(socket);
+                resolve();
+            });
+            server.listen(socketPath, () => {
+                if (generation !== this.generation) {
+                    fail(new Error("Computer helper start was superseded"));
+                    return;
+                }
+                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 startPipeHelper(executable, platformName, env, generation) {
+        if (!executable)
+            throw new ChatRoomError("UNSUPPORTED", `${platformName} Computer helper is missing`);
+        const child = spawn(executable, [], {
+            stdio: ["pipe", "pipe", "pipe"],
+            windowsHide: process.platform === "win32",
+            env,
+        });
+        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")));
+        await waitForSpawn(child);
+        if (generation !== this.generation || this.child !== child) {
+            child.kill();
+            throw new Error("Computer helper start was superseded");
+        }
+    }
+    failTransport(transport, error) {
+        const isCurrentSocket = transport === this.socket;
+        const isCurrentChild = transport === this.child;
+        if (!isCurrentSocket && !isCurrentChild)
+            return;
+        this.generation += 1;
+        const cancelStarting = this.cancelStarting;
+        this.cancelStarting = null;
+        cancelStarting?.(error);
+        if (isCurrentSocket)
+            this.socket = null;
+        if (isCurrentChild)
+            this.child = null;
+        this.lines?.close();
+        this.lines = null;
+        this.cleanupSocketPath();
+        this.rejectPending(error);
+    }
+    reset(error) {
+        this.generation += 1;
+        const cancelStarting = this.cancelStarting;
+        this.cancelStarting = null;
+        cancelStarting?.(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);
+    }
+    rejectRequest(id, error) {
+        const item = this.pending.get(id);
+        if (!item)
+            return;
+        this.pending.delete(id);
+        clearTimeout(item.timer);
+        item.reject(error);
+    }
+    rejectPending(error) {
+        for (const item of this.pending.values()) {
+            clearTimeout(item.timer);
+            item.reject(error);
+        }
+        this.pending.clear();
+    }
+    cleanupSocketPath(target = this.socketPath) {
+        if (!target)
+            return;
+        rmSync(target, { force: true });
+        if (this.socketPath === target)
+            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 waitForSpawn(child) {
+    return new Promise((resolve, reject) => {
+        const onSpawn = () => {
+            cleanup();
+            resolve();
+        };
+        const onError = (error) => {
+            cleanup();
+            reject(error);
+        };
+        const onExit = () => {
+            cleanup();
+            reject(new Error("Computer helper exited before startup"));
+        };
+        const cleanup = () => {
+            child.off("spawn", onSpawn);
+            child.off("error", onError);
+            child.off("exit", onExit);
+        };
+        child.once("spawn", onSpawn);
+        child.once("error", onError);
+        child.once("exit", onExit);
+    });
+}
+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() {
+    return nativeHelperPath("macos", "ChatRoomComputerHelper.app");
+}
+function windowsHelperPath() {
+    return nativeHelperPath("windows", "chatroom-computer-helper.exe");
+}
+function linuxHelperPath() {
+    return nativeHelperPath("linux", "chatroom-computer-helper");
+}
+function nativeHelperPath(...parts) {
+    const target = path.join(projectRoot(), "dist", "native", ...parts);
+    return existsSync(target) ? target : null;
+}
+function linuxDesktopEnvironment() {
+    const env = { ...process.env };
+    const uid = typeof process.getuid === "function" ? process.getuid() : null;
+    if (!env.XDG_RUNTIME_DIR && uid !== null) {
+        const runtimeDir = `/run/user/${uid}`;
+        if (existsSync(runtimeDir))
+            env.XDG_RUNTIME_DIR = runtimeDir;
+    }
+    if (!env.DISPLAY) {
+        const display = activeX11Display(uid);
+        if (display) {
+            env.DISPLAY = display;
+            env.XDG_SESSION_TYPE = "x11";
+        }
+    }
+    if (!env.XAUTHORITY) {
+        const candidates = [
+            env.HOME ? path.join(env.HOME, ".Xauthority") : null,
+            env.XDG_RUNTIME_DIR
+                ? path.join(env.XDG_RUNTIME_DIR, "gdm", "Xauthority")
+                : null,
+        ];
+        const authority = candidates.find((candidate) => !!candidate && existsSync(candidate));
+        if (authority)
+            env.XAUTHORITY = authority;
+    }
+    if (!env.DBUS_SESSION_BUS_ADDRESS && env.XDG_RUNTIME_DIR) {
+        const bus = path.join(env.XDG_RUNTIME_DIR, "bus");
+        if (existsSync(bus))
+            env.DBUS_SESSION_BUS_ADDRESS = `unix:path=${bus}`;
+    }
+    return env;
+}
+function activeX11Display(uid) {
+    if (process.platform !== "linux" || uid === null)
+        return null;
+    const loginctl = existsSync("/usr/bin/loginctl")
+        ? "/usr/bin/loginctl"
+        : "loginctl";
+    const sessions = spawnSync(loginctl, ["list-sessions", "--no-legend", "--no-pager"], {
+        encoding: "utf8",
+        timeout: 2_000,
+    });
+    if (sessions.status !== 0 || !sessions.stdout)
+        return null;
+    const userId = String(uid);
+    for (const line of sessions.stdout.split("\n")) {
+        const [sessionId, sessionUid] = line.trim().split(/\s+/, 3);
+        if (!sessionId || sessionUid !== userId)
+            continue;
+        const details = spawnSync(loginctl, [
+            "show-session",
+            sessionId,
+            "--no-pager",
+            "-p",
+            "Type",
+            "-p",
+            "Active",
+            "-p",
+            "Display",
+        ], { encoding: "utf8", timeout: 2_000 });
+        if (details.status !== 0 || !details.stdout)
+            continue;
+        const values = Object.fromEntries(details.stdout
+            .split("\n")
+            .map((item) => item.split("=", 2))
+            .filter((item) => item.length === 2));
+        if (values.Type === "x11" && values.Active === "yes" && values.Display) {
+            return values.Display;
+        }
+    }
+    return null;
+}

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

@@ -0,0 +1,22 @@
+import { ChatRoomError } from "#core/errors/chatroom-error";
+import type { ComputerActionResult, ComputerSnapshot, ComputerStatus } from "./types.js";
+export declare const COMPUTER_NATIVE_PROTOCOL_VERSION = 1;
+export type ComputerNativeMethod = "status" | "requestPermission" | "snapshot" | "action";
+interface ComputerNativeResultMap {
+    status: Omit<ComputerStatus, "settings">;
+    requestPermission: Omit<ComputerStatus, "settings">;
+    snapshot: ComputerSnapshot;
+    action: ComputerActionResult;
+}
+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;
+export {};