@chatroomcp/chatroom 0.1.6 → 0.2.0

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

@@ -0,0 +1,58 @@
+import { ChatRoomError } from "../../core/errors/chatroom-error.js";
+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,26 @@
+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 readonly pending;
+    private sequence;
+    get platform(): ComputerPlatform;
+    get idle(): boolean;
+    request(method: ComputerNativeMethod, params: unknown): Promise<unknown>;
+    restart(reason?: string): void;
+    dispose(): Promise<void>;
+    private ensureStarted;
+    private startMacHelper;
+    private attachSocket;
+    private startWindowsHelper;
+    private failTransport;
+    private reset;
+    private rejectPending;
+    private cleanupSocketPath;
+    private handleLine;
+}

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";
+    }
+}