@chatroomcp/chatroom 0.2.0 → 0.2.1

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

@@ -15,9 +15,10 @@ export declare class ComputerNativeHost {
     restart(reason?: string): void;
     dispose(): Promise<void>;
     private ensureStarted;
+    private startHelper;
     private startMacHelper;
     private attachSocket;
-    private startWindowsHelper;
+    private startPipeHelper;
     private failTransport;
     private reset;
     private rejectPending;

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

@@ -1,5 +1,5 @@
 import { randomUUID } from "node:crypto";
-import { spawn } from "node:child_process";
+import { spawn, spawnSync, } from "node:child_process";
 import { chmodSync, existsSync, rmSync } from "node:fs";
 import { createServer } from "node:net";
 import { createInterface } from "node:readline";
@@ -21,6 +21,8 @@ export class ComputerNativeHost {
             return "macos";
         if (process.platform === "win32")
             return "windows";
+        if (process.platform === "linux")
+            return "linux";
         return "unsupported";
     }
     get idle() {
@@ -59,18 +61,16 @@ export class ComputerNativeHost {
         this.reset(new Error("Computer helper stopped"));
     }
     async ensureStarted() {
-        if (this.platform === "macos" && this.socket && !this.socket.destroyed)
+        const platform = this.platform;
+        if (platform === "macos" && this.socket && !this.socket.destroyed)
             return;
-        if (this.platform === "windows" && this.child && !this.child.killed)
+        if ((platform === "windows" || platform === "linux") &&
+            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"));
+        this.starting = this.startHelper(platform);
         try {
             await this.starting;
         }
@@ -78,6 +78,18 @@ export class ComputerNativeHost {
             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)
@@ -131,13 +143,13 @@ export class ComputerNativeHost {
         socket.once("error", (error) => this.failTransport(socket, error));
         socket.once("close", () => this.failTransport(socket, new Error("Computer helper exited")));
     }
-    async startWindowsHelper() {
-        const executable = windowsHelperPath();
+    async startPipeHelper(executable, platformName, env = process.env) {
         if (!executable)
-            throw new ChatRoomError("UNSUPPORTED", "Windows Computer helper is missing");
+            throw new ChatRoomError("UNSUPPORTED", `${platformName} Computer helper is missing`);
         const child = spawn(executable, [], {
             stdio: ["pipe", "pipe", "pipe"],
-            windowsHide: true,
+            windowsHide: process.platform === "win32",
+            env,
         });
         this.child = child;
         this.lines = createInterface({ input: child.stdout });
@@ -236,10 +248,88 @@ function projectRoot() {
     return path.resolve(path.dirname(current), "../../..");
 }
 function macHelperAppPath() {
-    const app = path.join(projectRoot(), "dist", "native", "macos", "ChatRoomComputerHelper.app");
-    return existsSync(app) ? app : null;
+    return nativeHelperPath("macos", "ChatRoomComputerHelper.app");
 }
 function windowsHelperPath() {
-    const executable = path.join(projectRoot(), "dist", "native", "windows", "chatroom-computer-helper.exe");
-    return existsSync(executable) ? executable : null;
+    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-schemas.d.ts

@@ -36,6 +36,7 @@ export declare const computerNativeStatusSchema: z.ZodObject<{
     platform: z.ZodEnum<{
         macos: "macos";
         windows: "windows";
+        linux: "linux";
         unsupported: "unsupported";
     }>;
     helper: z.ZodEnum<{

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

@@ -30,7 +30,7 @@ export const computerScreenshotSchema = z.object({
     data: z.string(),
 });
 export const computerNativeStatusSchema = z.object({
-    platform: z.enum(["macos", "windows", "unsupported"]),
+    platform: z.enum(["macos", "windows", "linux", "unsupported"]),
     helper: z.enum(["running", "stopped", "unavailable"]),
     permissions: z.object({
         accessibility: computerPermissionStateSchema,

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

@@ -1,5 +1,5 @@
 export type ComputerAccessScope = "local" | "remote";
-export type ComputerPlatform = "macos" | "windows" | "unsupported";
+export type ComputerPlatform = "macos" | "windows" | "linux" | "unsupported";
 export type ComputerHelperState = "running" | "stopped" | "unavailable";
 export type ComputerPermissionState = "granted" | "denied" | "unknown" | "not-required";
 export type ComputerPermission = "accessibility" | "screenRecording";