@chatroomcp/chatroom 0.1.7 → 0.2.1

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

@@ -0,0 +1,335 @@
+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.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";
+        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`;
+        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() {
+        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;
+        this.starting = this.startHelper(platform);
+        try {
+            await this.starting;
+        }
+        finally {
+            this.starting = null;
+        }
+    }
+    startHelper(platform) {
+        switch (platform) {
+            case "macos":
+                return this.startMacHelper();
+            case "windows":
+                return this.startPipeHelper(windowsHelperPath(), "Windows");
+            case "linux":
+                return this.startPipeHelper(linuxHelperPath(), "Linux X11", linuxDesktopEnvironment());
+            case "unsupported":
+                return Promise.reject(new ChatRoomError("UNSUPPORTED", "Computer Use is supported only on macOS, Windows, and Linux X11"));
+        }
+    }
+    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 startPipeHelper(executable, platformName, env = process.env) {
+        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")));
+    }
+    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() {
+    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,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";
+    }
+}