@skylandnpm/octopus-proxy 0.1.65 → 0.1.67

package/dist/{chunk-6RJKEA3I.js → chunk-4CKW4ICE.js}

@@ -4,15 +4,16 @@ import {
   PlatformDesktop,
   REMOTE_DEFAULTS,
   RemoteConfigSchema,
+  RemotePlatformRegistry,
   RemoteQualitySchema,
   SignalSchema,
   __commonJS,
   __toESM,
   assertDirectSignal,
-  probeRemote,
+  nativeDependencies,
   remoteSessionBudget,
   z
-} from "./chunk-GS3Q6EU5.js";
+} from "./chunk-OTKNRBZ7.js";
 
 // ../../node_modules/.pnpm/ajv@8.17.1/node_modules/ajv/dist/compile/codegen/code.js
 var require_code = __commonJS({
@@ -7812,8 +7813,8 @@ async function startDeviceControl(directory, devices, connections) {
 }
 
 // src/daemon.ts
-import { mkdir as mkdir9 } from "node:fs/promises";
-import { join as join15 } from "node:path";
+import { mkdir as mkdir10 } from "node:fs/promises";
+import { join as join16 } from "node:path";
 
 // src/workspace-diff.ts
 import { execFile as execFile2 } from "node:child_process";
@@ -13921,17 +13922,30 @@ var TerminalManager = class {
 import { execFile as execFile6 } from "node:child_process";
 import { promisify as promisify6 } from "node:util";
 import { userInfo as userInfo4 } from "node:os";
+import { lstat as lstat3 } from "node:fs/promises";
 var exec = promisify6(execFile6);
 var PlatformDesktopSession = class {
-  constructor(system = process.platform, environment = process.env, execute3 = async (args) => (await exec("loginctl", ["--no-ask-password", ...args], { timeout: 5e3, maxBuffer: 16384 })).stdout, account = userInfo4()) {
+  constructor(x11Session = "logind", system = process.platform, environment = process.env, execute3 = async (args) => (await exec("loginctl", ["--no-ask-password", ...args], { timeout: 5e3, maxBuffer: 16384 })).stdout, account = userInfo4(), inspectSocket = lstat3) {
+    this.x11Session = x11Session;
     this.system = system;
     this.environment = environment;
     this.execute = execute3;
     this.account = account;
+    this.inspectSocket = inspectSocket;
   }
   async sessionIdentity() {
     if (this.system === "darwin") return String(this.account.uid);
     if (this.system !== "linux") throw new Error("\u6B64\u5E73\u53F0\u4E0D\u652F\u6301\u8FDC\u7A0B\u684C\u9762\u4F1A\u8BDD");
+    if (this.x11Session === "standalone") {
+      const display = /^(?:unix)?:([0-9]+)(?:\.([0-9]+))?$/.exec(this.environment.DISPLAY ?? "");
+      if (!display || this.account.uid === 0 || this.environment.WAYLAND_DISPLAY || this.environment.XDG_SESSION_TYPE === "wayland") throw new Error("\u72EC\u7ACB X11 \u8FDC\u63A7\u9700\u8981\u975E root \u7528\u6237\u548C\u672C\u5730 DISPLAY\uFF08\u5982 :99\uFF09\uFF0C\u4E0D\u652F\u6301 Wayland \u6216\u8FDC\u7A0B X11");
+      const path = `/tmp/.X11-unix/X${Number(display[1])}`;
+      const socket = await this.inspectSocket(path).catch(() => {
+        throw new Error(`\u72EC\u7ACB X11 socket \u4E0D\u53EF\u7528\uFF1A${path}\uFF1B\u8BF7\u5148\u542F\u52A8 Xvfb/\u684C\u9762\u670D\u52A1`);
+      });
+      if (!socket.isSocket()) throw new Error(`\u72EC\u7ACB X11 \u8DEF\u5F84\u4E0D\u662F socket\uFF1A${path}`);
+      return `x11:${this.account.uid}:${Number(display[1])}.${Number(display[2] ?? 0)}:${socket.dev}:${socket.ino}:${socket.ctimeMs}`;
+    }
     const ids = this.environment.XDG_SESSION_ID ? [this.environment.XDG_SESSION_ID] : (await this.execute(["list-sessions", "--no-legend"])).trim().split("\n").map((line) => line.trim().split(/\s+/)[0]).filter(Boolean);
     const sessions = [];
     for (const id of ids) {
@@ -13946,8 +13960,49 @@ var PlatformDesktopSession = class {
 
 // src/remote-manager.ts
 import { fork } from "node:child_process";
-import { randomBytes as randomBytes2, randomUUID as randomUUID18 } from "node:crypto";
+import { randomBytes as randomBytes2, randomUUID as randomUUID19 } from "node:crypto";
+import { fileURLToPath as fileURLToPath5 } from "node:url";
+
+// src/remote-native.ts
+import { chmod as chmod5, mkdir as mkdir9, readFile as readFile10, rename as rename5, rm as rm3, stat as stat10, writeFile as writeFile7 } from "node:fs/promises";
+import { join as join14 } from "node:path";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
+import { createHash as createHash10, randomUUID as randomUUID18 } from "node:crypto";
+async function ensureRemoteHelper(stateDirectory, adapter = RemotePlatformRegistry.standard.resolve()) {
+  await mkdir9(stateDirectory, { recursive: true, mode: 448 });
+  const build = adapter.helperBuild();
+  const source = fileURLToPath4(new URL(`../native/${build.source}`, import.meta.url));
+  const target = join14(stateDirectory, "octopus-remote-desktop");
+  const stamp = `${target}.sha256`;
+  const fingerprint = createHash10("sha256").update(await readFile10(source)).update(JSON.stringify([adapter.context.platform, adapter.context.arch, build.flags])).digest("hex");
+  const existing = await stat10(target).catch(() => void 0);
+  if (existing?.isFile() && (existing.mode & 63) === 0 && await readFile10(stamp, "utf8").catch(() => "") === fingerprint) return target;
+  const temporary = `${target}.${randomUUID18()}`, temporaryStamp = `${temporary}.sha256`;
+  const args = build.args(source, temporary);
+  try {
+    await nativeDependencies.execute(build.compiler, args, { timeout: 6e4, maxBuffer: 16384 });
+    await chmod5(temporary, 448);
+    await writeFile7(temporaryStamp, fingerprint, { mode: 384 });
+    await rename5(temporary, target);
+    await rename5(temporaryStamp, stamp);
+    return target;
+  } catch {
+    throw new Error(build.error);
+  } finally {
+    await Promise.all([rm3(temporary, { force: true }), rm3(temporaryStamp, { force: true })]);
+  }
+}
+async function probeRemote(stateDirectory, config, adapter = RemotePlatformRegistry.standard.resolve()) {
+  const platformError = adapter.platformError();
+  if (platformError) throw new Error(platformError);
+  await import("@roamhq/wrtc").catch(() => {
+    throw new Error("WebRTC \u539F\u751F\u4F9D\u8D56\u4E0D\u53EF\u7528\uFF0C\u8BF7\u91CD\u65B0\u5B89\u88C5\u65B0\u7248 Proxy");
+  });
+  const helper = await ensureRemoteHelper(stateDirectory, adapter);
+  const result = JSON.parse((await nativeDependencies.execute(helper, ["check"], { timeout: 5e3, maxBuffer: 4096 })).stdout);
+  await adapter.checkDependencies(config);
+  return { helper, ...result };
+}
 
 // src/remote-stun.ts
 import { Resolver } from "node:dns/promises";
@@ -14014,13 +14069,13 @@ async function discoverRemoteStunUrls(hubUrl, configured, resolve5 = resolvePubl
 
 // src/remote-manager.ts
 function spawnWorker(message) {
-  const worker = fileURLToPath4(new URL(import.meta.url.endsWith(".ts") ? "./remote-worker.ts" : "./remote-worker.js", import.meta.url));
+  const worker = fileURLToPath5(new URL(import.meta.url.endsWith(".ts") ? "./remote-worker.ts" : "./remote-worker.js", import.meta.url));
   const child = fork(worker, [], { stdio: ["ignore", "ignore", "ignore", "ipc"], execArgv: import.meta.url.endsWith(".ts") ? ["--import", "tsx"] : [] });
   child.send({ kind: "init", ...message });
   return child;
 }
 var RemoteManager = class {
-  constructor(host, desktop, desktopSession, send, touch, workerFactory = spawnWorker, probe = probeRemote, discoverStun = discoverRemoteStunUrls) {
+  constructor(host, desktop, desktopSession, send, touch, workerFactory = spawnWorker, probe = probeRemote, discoverStun = discoverRemoteStunUrls, platformRegistry = RemotePlatformRegistry.standard) {
     this.host = host;
     this.desktop = desktop;
     this.desktopSession = desktopSession;
@@ -14029,22 +14084,25 @@ var RemoteManager = class {
     this.workerFactory = workerFactory;
     this.probe = probe;
     this.discoverStun = discoverStun;
+    this.platform = platformRegistry.resolve();
     this.config = RemoteConfigSchema.parse(host.desktopRemote ?? {});
   }
   current;
   stopping = false;
   config;
+  platform;
   stunUrls() {
     return this.config.stunUrls ?? defaultRemoteStunUrls(this.host.hubUrl);
   }
   async status() {
-    const base = { qualityModes: RemoteQualitySchema.options, platform: process.platform, passwordInput: process.platform === "darwin", enabled: this.config.enabled, busy: !!this.current, stunUrls: this.stunUrls(), budget: { ...REMOTE_DEFAULTS, totalBitrate: this.config.totalBitrate, videoMaxBitrate: this.config.videoMaxBitrate } };
+    const base = { qualityModes: RemoteQualitySchema.options, platform: this.platform.context.platform, passwordInput: this.platform.passwordInput, enabled: this.config.enabled, busy: !!this.current, stunUrls: this.stunUrls(), budget: { ...REMOTE_DEFAULTS, totalBitrate: this.config.totalBitrate, videoMaxBitrate: this.config.videoMaxBitrate } };
     if (!this.config.enabled) return { ...base, available: false, message: "\u4E3B\u673A\u5DF2\u5173\u95ED\u8FDC\u7A0B\u63A7\u5236" };
     try {
-      const permissions = await this.probe(this.host.stateDirectory, this.config);
-      const lockUnsupported = permissions.locked === true && permissions.lockCapture === false;
-      const available = permissions.session && permissions.capture && permissions.input && !lockUnsupported;
-      return { ...base, available, permissions, ...!available ? { message: lockUnsupported ? "\u9501\u5C4F\u8FDC\u63A7\u9700\u8981 macOS 14 \u53CA\u4EE5\u4E0A\u53CA\u65B0\u7248 Xcode Command Line Tools\uFF1B\u5F53\u524D\u4E3B\u673A\u8BF7\u5148\u672C\u5730\u89E3\u9501" : "\u8BF7\u68C0\u67E5\u4E3B\u673A\u56FE\u5F62\u4F1A\u8BDD\uFF0C\u5E76\u4E3A\u5B9E\u9645\u8FD0\u884C Proxy \u7684\u7A0B\u5E8F\u6388\u6743\u5C4F\u5E55\u5F55\u5236\u548C\u8F85\u52A9\u529F\u80FD" } : {} };
+      const permissions = await this.probe(this.host.stateDirectory, this.config, this.platform);
+      const message = this.platform.unavailableReason(permissions);
+      const available = message === void 0;
+      if (available) await this.desktopSession.sessionIdentity();
+      return { ...base, available, permissions, ...!available ? { message } : {} };
     } catch (error) {
       return { ...base, available: false, message: error instanceof Error ? error.message : "\u8FDC\u63A7\u4F9D\u8D56\u4E0D\u53EF\u7528" };
     }
@@ -14080,15 +14138,16 @@ var RemoteManager = class {
     if (this.current) throw new Error("\u4E3B\u673A\u6B63\u5728\u88AB\u63A7\u5236");
     const quality = RemoteQualitySchema.parse(payload.quality ?? "hd");
     const budget = remoteSessionBudget(this.config, quality, payload.quality === void 0);
-    const session = { remoteId: randomUUID18(), owner, closed: false, signaling: Promise.resolve(), signals: 0, signalWindow: Date.now(), candidates: 0 };
+    const session = { remoteId: randomUUID19(), owner, closed: false, signaling: Promise.resolve(), signals: 0, signalWindow: Date.now(), candidates: 0 };
     this.current = session;
     try {
       const [permissions, stunUrls] = await Promise.all([
-        this.probe(this.host.stateDirectory, this.config),
+        this.probe(this.host.stateDirectory, this.config, this.platform),
         this.discoverStun(this.host.hubUrl, this.config.stunUrls)
       ]);
       if (!permissions.session || !permissions.capture || !permissions.input) throw new Error("\u8FDC\u63A7\u9700\u8981\u4E3B\u673A\u56FE\u5F62\u4F1A\u8BDD\u3001\u5C4F\u5E55\u5F55\u5236\u53CA\u8F85\u52A9\u529F\u80FD\u6743\u9650");
-      if (permissions.locked === true && permissions.lockCapture === false) throw new Error("\u9501\u5C4F\u8FDC\u63A7\u9700\u8981 macOS 14 \u53CA\u4EE5\u4E0A\u53CA\u65B0\u7248 Xcode Command Line Tools\uFF1B\u5F53\u524D\u4E3B\u673A\u8BF7\u5148\u672C\u5730\u89E3\u9501");
+      const unavailable = this.platform.unavailableReason(permissions);
+      if (unavailable) throw new Error(unavailable);
       const identity = await this.desktopSession.sessionIdentity();
       const display = (await this.desktop.list()).find((d) => d.id === payload.displayId);
       if (!display) throw new Error("\u663E\u793A\u5668\u5DF2\u65AD\u5F00\uFF0C\u8BF7\u5237\u65B0\u663E\u793A\u5668\u5217\u8868");
@@ -14159,16 +14218,16 @@ var RemoteManager = class {
 };
 
 // src/tool-selection.ts
-import { randomBytes as randomBytes3, randomUUID as randomUUID19 } from "node:crypto";
-import { access as access3, constants as constants6, readFile as readFile10 } from "node:fs/promises";
+import { randomBytes as randomBytes3, randomUUID as randomUUID20 } from "node:crypto";
+import { access as access3, constants as constants6, readFile as readFile11 } from "node:fs/promises";
 import { platform as platform5 } from "node:os";
 import { isDeepStrictEqual as isDeepStrictEqual2 } from "node:util";
 
 // src/node-resolution.ts
-import { realpath as realpath7, stat as stat10 } from "node:fs/promises";
+import { realpath as realpath7, stat as stat11 } from "node:fs/promises";
 import { execFile as execFile7 } from "node:child_process";
 import { promisify as promisify7 } from "node:util";
-import { join as join14 } from "node:path";
+import { join as join15 } from "node:path";
 import { homedir as homedir2, platform as platform4 } from "node:os";
 var run4 = promisify7(execFile7);
 var VERSION_MANAGED_SEGMENTS = /* @__PURE__ */ new Set([".nvm", "nvm", ".volta", "volta", ".fnm", "fnm", ".asdf", "asdf", ".mise", "mise"]);
@@ -14212,15 +14271,15 @@ async function resolveNodePath(options = {}) {
   return { nodePath: null, source: "exec" };
 }
 function toolSearchDirs(kind) {
-  const dirs = [...describeTool(kind).searchDirs, join14(homedir2(), ".local", "bin"), join14(homedir2(), ".opencode", "bin"), join14(homedir2(), ".codex", "bin")];
+  const dirs = [...describeTool(kind).searchDirs, join15(homedir2(), ".local", "bin"), join15(homedir2(), ".opencode", "bin"), join15(homedir2(), ".codex", "bin")];
   return [...new Set(dirs)];
 }
 async function resolveCommandOnPath(name, extraDirs = []) {
   const dirs = [...(process.env.PATH ?? "").split(":"), ...extraDirs].filter(Boolean);
   for (const dir of new Set(dirs)) {
-    const full = join14(dir, name);
+    const full = join15(dir, name);
     try {
-      const info = await stat10(full);
+      const info = await stat11(full);
       if (info.isFile() && info.mode & 73) return full;
     } catch {
     }
@@ -14303,7 +14362,7 @@ var ToolSelection = class {
     });
   }
   modelCommand(projectId) {
-    return { type: "command", id: randomUUID19(), botId: this.config.botId, operation: "configuration.models", projectId, payload: {} };
+    return { type: "command", id: randomUUID20(), botId: this.config.botId, operation: "configuration.models", projectId, payload: {} };
   }
   profiles(raw) {
     return raw.toolProfiles && typeof raw.toolProfiles === "object" && !Array.isArray(raw.toolProfiles) ? raw.toolProfiles : {};
@@ -14345,7 +14404,7 @@ var ToolSelection = class {
     if (!isDeepStrictEqual2(JSON.parse(JSON.stringify(disk.tool)), JSON.parse(JSON.stringify(this.config.tool))) || !isDeepStrictEqual2(disk.projects, this.config.projects) || disk.botId !== this.config.botId || disk.secretKey !== this.config.secretKey) {
       throw new Error("Proxy \u914D\u7F6E\u5DF2\u5728\u4E3B\u673A\u4E0A\u88AB\u4FEE\u6539\uFF1B\u8BF7\u91CD\u542F Proxy \u540E\u518D\u5207\u6362\u667A\u80FD\u4F53");
     }
-    return JSON.parse(await readFile10(this.configPath, "utf8"));
+    return JSON.parse(await readFile11(this.configPath, "utf8"));
   }
   async release(instance) {
     instance.adapter.close();
@@ -14362,14 +14421,14 @@ var ToolSelection = class {
 // src/daemon.ts
 async function runDaemon(configPath, authenticate = verifyHostPassword) {
   const config = await loadConfig(configPath);
-  await mkdir9(config.stateDirectory, { recursive: true, mode: 448 });
-  const workspace = new Workspace(config.projects), uploads = new Uploads(workspace, join15(config.stateDirectory, "uploads")), journal = new Journal(join15(config.stateDirectory, "journal"));
+  await mkdir10(config.stateDirectory, { recursive: true, mode: 448 });
+  const workspace = new Workspace(config.projects), uploads = new Uploads(workspace, join16(config.stateDirectory, "uploads")), journal = new Journal(join16(config.stateDirectory, "journal"));
   let secureChat;
   function emit(projectId, event, data) {
     secureChat?.publish(projectId, event, data);
   }
   const terminals = new TerminalManager(workspace, (owner, project, event, data) => secureChat?.sendTo(owner, project, event, data));
-  const desktopBackend = new PlatformDesktop(config.stateDirectory), desktopSession = new PlatformDesktopSession();
+  const desktopBackend = new PlatformDesktop(config.stateDirectory), desktopSession = new PlatformDesktopSession(config.desktopRemote?.x11Session);
   const desktop = new DesktopManager(desktopBackend);
   const remote = new RemoteManager(
     config,
@@ -14385,7 +14444,7 @@ async function runDaemon(configPath, authenticate = verifyHostPassword) {
     });
     return { runtime, adapter };
   });
-  const artifacts = new Artifacts(workspace, join15(config.stateDirectory, "artifacts"), emit);
+  const artifacts = new Artifacts(workspace, join16(config.stateDirectory, "artifacts"), emit);
   const projectRegistry = () => new ProjectRegistry(configPath, config, tools.current.runtime, tools.current.adapter, (resetProjects) => {
     for (const id of resetProjects) terminals.closeProject(id);
   });

package/dist/{chunk-GS3Q6EU5.js → chunk-OTKNRBZ7.js}

@@ -4104,7 +4104,8 @@ var RemoteConfigSchema = z.object({
   stunUrls: z.array(stunUrl).min(1).max(4).optional(),
   totalBitrate: z.number().int().min(1e5).max(REMOTE_DEFAULTS.totalBitrate).default(REMOTE_DEFAULTS.totalBitrate),
   videoMaxBitrate: z.number().int().min(5e4).max(REMOTE_DEFAULTS.videoMaxBitrate).default(REMOTE_DEFAULTS.videoMaxBitrate),
-  ffmpeg: z.string().min(1).default("ffmpeg")
+  ffmpeg: z.string().min(1).default("ffmpeg"),
+  x11Session: z.enum(["logind", "standalone"]).default("logind")
 }).strict().refine((c) => c.videoMaxBitrate <= c.totalBitrate * 0.8, "\u89C6\u9891\u989D\u5EA6\u4E0D\u5F97\u8D85\u8FC7\u603B\u9884\u7B97\u7684 80%");
 function remoteSessionBudget(config, quality, legacy = false) {
   const profile = legacy ? REMOTE_LEGACY_PROFILE : REMOTE_QUALITY_PROFILES[quality];
@@ -4448,61 +4449,16 @@ var DesktopManager = class {
   }
 };
 
-// src/remote-native.ts
+// src/remote/native-process.ts
 import { execFile as execFile2, spawn } from "node:child_process";
 import { promisify as promisify2 } from "node:util";
-import { chmod as chmod2, mkdir as mkdir2, readFile as readFile2, rename as rename2, rm as rm2, stat as stat2, writeFile as writeFile2 } from "node:fs/promises";
-import { join as join2 } from "node:path";
-import { fileURLToPath as fileURLToPath2 } from "node:url";
-import { createHash as createHash2, randomUUID as randomUUID2 } from "node:crypto";
 var exec = promisify2(execFile2);
-function supportedRemotePlatform(system = process.platform, arch = process.arch, env = process.env) {
-  return system === "darwin" && ["arm64", "x64"].includes(arch) || system === "linux" && arch === "x64" && !!env.DISPLAY && !env.WAYLAND_DISPLAY && env.XDG_SESSION_TYPE !== "wayland";
-}
-async function ensureRemoteHelper(stateDirectory) {
-  await mkdir2(stateDirectory, { recursive: true, mode: 448 });
-  const mac = process.platform === "darwin";
-  const source = fileURLToPath2(new URL(mac ? "../native/remote-macos.m" : "../native/remote-x11.c", import.meta.url));
-  const target = join2(stateDirectory, "octopus-remote-desktop");
-  const stamp = `${target}.sha256`;
-  const flags = mac ? ["-O2", "-fobjc-arc", "-mmacosx-version-min=12.3", "-framework", "Foundation", "-framework", "AppKit", "-framework", "ScreenCaptureKit", "-framework", "CoreMedia", "-framework", "CoreVideo", "-framework", "ApplicationServices", "-framework", "Carbon", "-framework", "IOKit", "-framework", "VideoToolbox"] : ["-O2", "-lX11", "-lXtst"];
-  const fingerprint = createHash2("sha256").update(await readFile2(source)).update(JSON.stringify([process.platform, process.arch, flags])).digest("hex");
-  const existing = await stat2(target).catch(() => void 0);
-  if (existing?.isFile() && (existing.mode & 63) === 0 && await readFile2(stamp, "utf8").catch(() => "") === fingerprint) return target;
-  const temporary = `${target}.${randomUUID2()}`, temporaryStamp = `${temporary}.sha256`;
-  const args = mac ? [...flags, source, "-o", temporary] : ["-O2", source, "-o", temporary, "-lX11", "-lXtst"];
-  try {
-    await exec(mac ? "/usr/bin/clang" : "cc", args, { timeout: 6e4, maxBuffer: 16384 });
-    await chmod2(temporary, 448);
-    await writeFile2(temporaryStamp, fingerprint, { mode: 384 });
-    await rename2(temporary, target);
-    await rename2(temporaryStamp, stamp);
-    return target;
-  } catch {
-    throw new Error(mac ? "\u8FDC\u63A7\u8F85\u52A9\u7A0B\u5E8F\u7F16\u8BD1\u5931\u8D25\uFF0C\u8BF7\u5B89\u88C5 Xcode Command Line Tools" : "\u8FDC\u63A7\u8F85\u52A9\u7A0B\u5E8F\u7F16\u8BD1\u5931\u8D25\uFF0C\u8BF7\u5B89\u88C5 cc\u3001libx11-dev\u3001libxtst-dev");
-  } finally {
-    await Promise.all([rm2(temporary, { force: true }), rm2(temporaryStamp, { force: true })]);
-  }
-}
-async function probeRemote(stateDirectory, config) {
-  if (!supportedRemotePlatform()) throw new Error("\u8FDC\u63A7\u9996\u7248\u652F\u6301 macOS 12.3+ \u4E0E Linux X11 x64\uFF1BWayland\u3001\u65E0\u56FE\u5F62\u4F1A\u8BDD\u6682\u4E0D\u652F\u6301");
-  await import("@roamhq/wrtc").catch(() => {
-    throw new Error("WebRTC \u539F\u751F\u4F9D\u8D56\u4E0D\u53EF\u7528\uFF0C\u8BF7\u91CD\u65B0\u5B89\u88C5\u65B0\u7248 Proxy");
-  });
-  const helper = await ensureRemoteHelper(stateDirectory);
-  const result = JSON.parse((await exec(helper, ["check"], { timeout: 5e3, maxBuffer: 4096 })).stdout);
-  if (process.platform === "linux") {
-    const version = await exec(config.ffmpeg, ["-version"], { timeout: 5e3, maxBuffer: 32768 }).catch(() => {
-      throw new Error("\u8BF7\u5B89\u88C5\u652F\u6301 x11grab \u7684 LGPL FFmpeg");
-    });
-    assertLgplFFmpeg(version.stdout);
-    const devices = await exec(config.ffmpeg, ["-hide_banner", "-devices"], { timeout: 5e3, maxBuffer: 32768 });
-    if (!devices.stdout.includes("x11grab")) throw new Error("FFmpeg \u7F3A\u5C11 x11grab \u91C7\u96C6\u652F\u6301");
-  }
-  return { helper, ...result };
-}
-function nativeProcess(helper, displayId, video) {
-  return spawn(helper, ["serve", displayId, String(video.width), String(video.height), String(video.fps)], { stdio: ["pipe", "pipe", "pipe", "pipe"] });
+var nativeDependencies = {
+  execute: async (file, args, options) => ({ stdout: String((await exec(file, args, options)).stdout) }),
+  spawn
+};
+function nativeProcess(helper, displayId, video, dependencies = nativeDependencies) {
+  return dependencies.spawn(helper, ["serve", displayId, String(video.width), String(video.height), String(video.fps)], { stdio: ["pipe", "pipe", "pipe", "pipe"] });
 }
 function terminateNative(child) {
   if (!child) return;
@@ -4513,6 +4469,307 @@ function terminateNative(child) {
   child.once("exit", () => clearTimeout(timer));
 }
 
+// src/remote/native-session.ts
+var NativeSession = class {
+  constructor(options, dependencies = nativeDependencies) {
+    this.options = options;
+    this.dependencies = dependencies;
+    this.video = options.video;
+  }
+  helper;
+  stopped = false;
+  video;
+  starting;
+  start() {
+    return this.starting ??= this.startOnce().catch((error) => {
+      this.stop();
+      throw error;
+    });
+  }
+  async startOnce() {
+    if (this.stopped) return;
+    await this.prepare();
+    if (this.stopped) return;
+    const child = nativeProcess(this.options.helper, this.options.display.id, this.video, this.dependencies);
+    this.helper = child;
+    child.on("error", () => this.fail("\u4E3B\u673A\u8F93\u5165\u8F85\u52A9\u7A0B\u5E8F\u4E0D\u53EF\u7528"));
+    child.on("exit", () => this.fail("\u4E3B\u673A\u6743\u9650\u3001\u663E\u793A\u5668\u6216\u56FE\u5F62\u4F1A\u8BDD\u5DF2\u53D8\u5316"));
+    child.stdin?.on("error", () => this.fail("\u4E3B\u673A\u8F93\u5165\u8FDE\u63A5\u5DF2\u5173\u95ED"));
+    let lines = "";
+    child.stdout?.on("data", (chunk) => {
+      if (this.stopped) return;
+      lines += String(chunk);
+      if (lines.length > 15e5) {
+        this.fail("\u4E3B\u673A\u526A\u8D34\u677F\u8D85\u8FC7\u4E0A\u9650");
+        return;
+      }
+      let end;
+      while (!this.stopped && (end = lines.indexOf("\n")) >= 0) {
+        const line = lines.slice(0, end);
+        lines = lines.slice(end + 1);
+        try {
+          const message = JSON.parse(line);
+          if (message.kind === "error") {
+            this.fail("\u4E3B\u673A\u6743\u9650\u3001\u663E\u793A\u5668\u6216\u56FE\u5F62\u4F1A\u8BDD\u5DF2\u53D8\u5316");
+            return;
+          }
+          this.options.onMessage(message);
+        } catch {
+          this.fail("\u4E3B\u673A\u8F85\u52A9\u7A0B\u5E8F\u8FD4\u56DE\u65E0\u6548\u6570\u636E");
+        }
+      }
+    });
+    this.startCapture(child);
+  }
+  async prepare() {
+  }
+  stopCapture() {
+  }
+  fail(message) {
+    if (this.stopped) return;
+    this.stop();
+    this.options.onError(message);
+  }
+  writeCommand(line) {
+    if (this.stopped || !this.helper?.stdin || this.helper.stdin.destroyed) return;
+    if (this.helper.stdin.writableLength > 2 * 1024 * 1024) {
+      this.fail("\u4E3B\u673A\u8F93\u5165\u5904\u7406\u8D85\u65F6");
+      return;
+    }
+    this.helper.stdin.write(`${line}
+`);
+  }
+  input(input) {
+    switch (input.kind) {
+      case "pointer":
+        this.writeCommand(`pointer ${input.x} ${input.y}`);
+        break;
+      case "button":
+        this.writeCommand(`button ${input.x} ${input.y} ${input.button} ${input.down ? 1 : 0}`);
+        break;
+      case "wheel":
+        this.writeCommand(`wheel ${input.x} ${input.y} ${Math.round(input.dx)} ${Math.round(input.dy)}`);
+        break;
+      case "key":
+        this.writeCommand(`key ${input.code} ${input.down ? 1 : 0}`);
+        break;
+      case "text":
+        this.writeCommand(`text ${input.terminal ? 1 : 0} ${Buffer.from(input.text).toString("base64")}`);
+        break;
+      case "release":
+        this.writeCommand("release");
+        break;
+    }
+  }
+  stop() {
+    if (this.stopped) return;
+    this.stopped = true;
+    this.stopCapture();
+    const helper = this.helper;
+    this.helper = void 0;
+    terminateNative(helper);
+  }
+};
+
+// src/remote/platform-adapter.ts
+function unsupportedPlatform(context) {
+  return `\u8FDC\u63A7\u4E0D\u652F\u6301\u5F53\u524D\u5E73\u53F0 ${context.platform}/${context.arch}\uFF1B\u9700\u8981 macOS 12.3+ \u6216 Linux X11\uFF08x64/ARM64\uFF09`;
+}
+function missingPermissions(permissions) {
+  if (!permissions.session || !permissions.capture || !permissions.input) return "\u8BF7\u68C0\u67E5\u4E3B\u673A\u56FE\u5F62\u4F1A\u8BDD\uFF0C\u5E76\u4E3A\u5B9E\u9645\u8FD0\u884C Proxy \u7684\u7A0B\u5E8F\u6388\u6743\u5C4F\u5E55\u5F55\u5236\u548C\u8F85\u52A9\u529F\u80FD";
+}
+
+// src/remote/linux-x11-adapter.ts
+var LinuxX11RemoteAdapter = class {
+  constructor(context, dependencies = nativeDependencies) {
+    this.context = context;
+    this.dependencies = dependencies;
+  }
+  passwordInput = false;
+  platformError() {
+    if (!["arm64", "x64"].includes(this.context.arch)) return unsupportedPlatform(this.context);
+    const env = this.context.env;
+    if (env.WAYLAND_DISPLAY || env.XDG_SESSION_TYPE === "wayland") return "\u8FDC\u63A7\u6682\u4E0D\u652F\u6301 Wayland\uFF0C\u8BF7\u4F7F\u7528 X11 \u684C\u9762\u4F1A\u8BDD";
+    if (!env.DISPLAY) return "Proxy \u672A\u8FDE\u63A5 X11 \u56FE\u5F62\u4F1A\u8BDD\uFF1B\u8BF7\u4E3A\u5B9E\u9645\u8FD0\u884C Proxy \u7684\u670D\u52A1\u8BBE\u7F6E\u684C\u9762\u7528\u6237\u7684 DISPLAY \u548C XAUTHORITY\uFF0C\u5BB9\u5668\u4E2D\u8BF7\u5148\u542F\u52A8 Xvfb/\u684C\u9762\u670D\u52A1";
+  }
+  helperBuild() {
+    return { source: "remote-x11.c", compiler: "cc", flags: ["-O2", "-lX11", "-lXtst"], args: (source, target) => ["-O2", source, "-o", target, "-lX11", "-lXtst"], error: "\u8FDC\u63A7\u8F85\u52A9\u7A0B\u5E8F\u7F16\u8BD1\u5931\u8D25\uFF0C\u8BF7\u5B89\u88C5 cc\u3001libx11-dev\u3001libxtst-dev" };
+  }
+  async checkDependencies(config) {
+    const execute = this.dependencies.execute;
+    const version = await execute(config.ffmpeg, ["-version"], { timeout: 5e3, maxBuffer: 32768 }).catch(() => {
+      throw new Error("\u8BF7\u5B89\u88C5\u652F\u6301 x11grab \u7684 LGPL FFmpeg");
+    });
+    assertLgplFFmpeg(version.stdout);
+    const devices = await execute(config.ffmpeg, ["-hide_banner", "-devices"], { timeout: 5e3, maxBuffer: 32768 });
+    if (!devices.stdout.includes("x11grab")) throw new Error("FFmpeg \u7F3A\u5C11 x11grab \u91C7\u96C6\u652F\u6301");
+  }
+  unavailableReason = missingPermissions;
+  createSession(options) {
+    return new LinuxX11RemoteSession(options, this.context, this.dependencies);
+  }
+};
+var LinuxX11RemoteSession = class extends NativeSession {
+  constructor(options, context, dependencies) {
+    super(options, dependencies);
+    this.context = context;
+  }
+  capture;
+  geometry;
+  async prepare() {
+    const displays = parseXrandr((await this.dependencies.execute("xrandr", ["--listactivemonitors"], { timeout: 5e3 })).stdout);
+    if (this.stopped) return;
+    const display = displays.find((d) => d.id === this.options.display.id);
+    if (!display || display.width !== this.options.display.width || display.height !== this.options.display.height) throw new Error("display");
+    this.geometry = { x: display.x, y: display.y, width: display.width, height: display.height };
+  }
+  startCapture(_child) {
+    const g = this.geometry;
+    this.writeCommand(`geometry ${g.x} ${g.y} ${g.width} ${g.height}`);
+    this.captureFrames();
+  }
+  captureFrames() {
+    this.stopCapture();
+    if (this.stopped) return;
+    const g = this.geometry, { width, height, fps } = this.video;
+    const child = this.dependencies.spawn(this.options.config.ffmpeg, ["-nostdin", "-hide_banner", "-loglevel", "error", "-f", "x11grab", "-framerate", String(fps), "-video_size", `${g.width}x${g.height}`, "-grab_x", String(g.x), "-grab_y", String(g.y), "-draw_mouse", "1", "-i", this.context.env.DISPLAY, "-vf", `scale=${width}:${height}`, "-pix_fmt", "yuv420p", "-f", "rawvideo", "pipe:1"], { stdio: ["ignore", "pipe", "ignore"], env: this.context.env });
+    this.capture = child;
+    const current = () => !this.stopped && this.capture === child;
+    let buffer = Buffer.alloc(0);
+    const length = width * height * 1.5;
+    child.stdout.on("data", (chunk) => {
+      if (!current()) return;
+      buffer = Buffer.concat([buffer, chunk]);
+      if (buffer.length > length * 4) {
+        this.fail("\u4E3B\u673A\u91C7\u96C6\u7F13\u51B2\u533A\u8D85\u9650");
+        return;
+      }
+      if (buffer.length >= length) {
+        const count = Math.floor(buffer.length / length), frame = buffer.subarray((count - 1) * length, count * length);
+        buffer = buffer.subarray(count * length);
+        this.options.onFrame({ width, height, data: new Uint8Array(frame) });
+      }
+    });
+    child.on("error", () => {
+      if (current()) this.fail("FFmpeg \u91C7\u96C6\u5931\u8D25");
+    });
+    child.on("exit", () => {
+      if (current()) this.fail("\u663E\u793A\u5668\u5DF2\u53D8\u5316\u6216 FFmpeg \u91C7\u96C6\u5931\u8D25");
+    });
+  }
+  setVideo(video) {
+    this.video = video;
+    if (this.helper && !this.stopped) this.captureFrames();
+  }
+  stopCapture() {
+    const child = this.capture;
+    this.capture = void 0;
+    terminateNative(child);
+  }
+};
+
+// src/remote/macos-adapter.ts
+var MAC_LOCK_CAPTURE_ERROR = "\u9501\u5C4F\u8FDC\u63A7\u9700\u8981 macOS 14 \u53CA\u4EE5\u4E0A\u53CA\u65B0\u7248 Xcode Command Line Tools\uFF1B\u5F53\u524D\u4E3B\u673A\u8BF7\u5148\u672C\u5730\u89E3\u9501";
+var MacOSRemoteAdapter = class {
+  constructor(context, dependencies = nativeDependencies) {
+    this.context = context;
+    this.dependencies = dependencies;
+  }
+  passwordInput = true;
+  platformError() {
+    if (!["arm64", "x64"].includes(this.context.arch)) return unsupportedPlatform(this.context);
+  }
+  helperBuild() {
+    const flags = ["-O2", "-fobjc-arc", "-mmacosx-version-min=12.3", "-framework", "Foundation", "-framework", "AppKit", "-framework", "ScreenCaptureKit", "-framework", "CoreMedia", "-framework", "CoreVideo", "-framework", "ApplicationServices", "-framework", "Carbon", "-framework", "IOKit", "-framework", "VideoToolbox"];
+    return { source: "remote-macos.m", compiler: "/usr/bin/clang", flags, args: (source, target) => [...flags, source, "-o", target], error: "\u8FDC\u63A7\u8F85\u52A9\u7A0B\u5E8F\u7F16\u8BD1\u5931\u8D25\uFF0C\u8BF7\u5B89\u88C5 Xcode Command Line Tools" };
+  }
+  async checkDependencies(_config) {
+  }
+  unavailableReason(permissions) {
+    if (permissions.locked === true && permissions.lockCapture === false) return MAC_LOCK_CAPTURE_ERROR;
+    return missingPermissions(permissions);
+  }
+  createSession(options) {
+    return new MacOSRemoteSession(options, this.dependencies);
+  }
+};
+var MacOSRemoteSession = class extends NativeSession {
+  startCapture(child) {
+    const stream = child.stdio[3];
+    let buffer = Buffer.alloc(0);
+    stream.on("data", (chunk) => {
+      if (this.stopped) return;
+      buffer = Buffer.concat([buffer, chunk]);
+      if (buffer.length > REMOTE_DEFAULTS.maxWidth * REMOTE_DEFAULTS.maxHeight * 3 + 24) {
+        this.fail("\u8FDC\u63A7\u753B\u9762\u7F13\u51B2\u533A\u8D85\u9650");
+        return;
+      }
+      let latest;
+      while (buffer.length >= 12) {
+        const width = buffer.readUInt32BE(0), height = buffer.readUInt32BE(4), length = buffer.readUInt32BE(8);
+        if (!width || !height || width > REMOTE_DEFAULTS.maxWidth || height > REMOTE_DEFAULTS.maxHeight || width % 2 || height % 2 || length !== width * height * 1.5) {
+          this.fail("\u4E3B\u673A\u753B\u9762\u683C\u5F0F\u65E0\u6548");
+          return;
+        }
+        if (buffer.length < length + 12) break;
+        latest = { width, height, data: new Uint8Array(buffer.subarray(12, 12 + length)) };
+        buffer = buffer.subarray(12 + length);
+      }
+      if (latest) this.options.onFrame(latest);
+    });
+  }
+  setVideo(video) {
+    this.video = video;
+    this.writeCommand(`video ${video.width} ${video.height} ${video.fps}`);
+  }
+  input(input) {
+    if (input.kind === "password") this.writeCommand(`password ${Buffer.from(input.text).toString("base64")}`);
+    else super.input(input);
+  }
+};
+
+// src/remote/unsupported-adapter.ts
+var UnsupportedRemoteAdapter = class {
+  constructor(context) {
+    this.context = context;
+  }
+  passwordInput = false;
+  platformError() {
+    return unsupportedPlatform(this.context);
+  }
+  helperBuild() {
+    throw new Error(this.platformError());
+  }
+  async checkDependencies(_config) {
+    throw new Error(this.platformError());
+  }
+  unavailableReason(_permissions) {
+    return this.platformError();
+  }
+  createSession(_options) {
+    throw new Error(this.platformError());
+  }
+};
+
+// src/remote/platform-registry.ts
+var RemotePlatformRegistry = class _RemotePlatformRegistry {
+  static standard = new _RemotePlatformRegistry({
+    darwin: (context) => new MacOSRemoteAdapter(context),
+    linux: (context) => new LinuxX11RemoteAdapter(context)
+  });
+  factories;
+  constructor(factories) {
+    this.factories = Object.freeze({ ...factories });
+  }
+  withAdapter(platform, factory) {
+    return new _RemotePlatformRegistry({ ...this.factories, [platform]: factory });
+  }
+  resolve(context = { platform: process.platform, arch: process.arch, env: process.env }) {
+    const factory = Object.hasOwn(this.factories, context.platform) ? this.factories[context.platform] : void 0;
+    return factory?.(context) ?? new UnsupportedRemoteAdapter(context);
+  }
+};
+
 export {
   __commonJS,
   __toESM,
@@ -4533,10 +4790,8 @@ export {
   DESKTOP_PERMISSION_GUIDANCE,
   requestDesktopPermission,
   checkDesktop,
-  parseXrandr,
   PlatformDesktop,
   DesktopManager,
-  probeRemote,
-  nativeProcess,
-  terminateNative
+  nativeDependencies,
+  RemotePlatformRegistry
 };

package/dist/cli.js

@@ -35,13 +35,13 @@ import {
   supportedPlatform,
   systemdUnitPath,
   toolSearchDirs
-} from "./chunk-6RJKEA3I.js";
+} from "./chunk-4CKW4ICE.js";
 import {
   DESKTOP_PERMISSION_GUIDANCE,
   PlatformDesktop,
   checkDesktop,
   requestDesktopPermission
-} from "./chunk-GS3Q6EU5.js";
+} from "./chunk-OTKNRBZ7.js";
 
 // src/cli.ts
 import { spawn as spawn2 } from "node:child_process";
@@ -364,7 +364,7 @@ async function runDoctor(opts) {
   }
   if (config) {
     results.push(...await checkDesktop(config.stateDirectory));
-    const remote = new RemoteManager(config, new PlatformDesktop(config.stateDirectory), new PlatformDesktopSession(), () => {
+    const remote = new RemoteManager(config, new PlatformDesktop(config.stateDirectory), new PlatformDesktopSession(config.desktopRemote?.x11Session), () => {
     }, () => false);
     try {
       const status = await remote.status();

package/dist/main.js

@@ -2,8 +2,8 @@
 import {
   ConfigError,
   runDaemon
-} from "./chunk-6RJKEA3I.js";
-import "./chunk-GS3Q6EU5.js";
+} from "./chunk-4CKW4ICE.js";
+import "./chunk-OTKNRBZ7.js";
 
 // src/main.ts
 runDaemon(process.env.OCTOPUS_PROXY_CONFIG ?? "proxy.json").catch((error) => {

package/dist/remote-worker.js

@@ -1,25 +1,20 @@
 #!/usr/bin/env node
 import {
   InputSchema,
-  REMOTE_DEFAULTS,
   REMOTE_LEGACY_PROFILE,
   REMOTE_QUALITY_PROFILES,
   RemoteInputOrder,
+  RemotePlatformRegistry,
   SignalSchema,
   assertDirectSignal,
   capVideoSdp,
   fitVideo,
-  nativeProcess,
-  parseXrandr,
   remoteResolutionTiers,
-  remoteSessionBudget,
-  terminateNative
-} from "./chunk-GS3Q6EU5.js";
+  remoteSessionBudget
+} from "./chunk-OTKNRBZ7.js";
 
 // src/remote-worker.ts
 import rtc from "@roamhq/wrtc";
-import { spawn, execFile } from "node:child_process";
-import { promisify } from "node:util";
 import { timingSafeEqual } from "node:crypto";
 
 // src/remote-budget.ts
@@ -158,7 +153,6 @@ var RemoteLiveness = class {
 };
 
 // src/remote-worker.ts
-var exec = promisify(execFile);
 var post = (kind, data = {}) => {
   if (process.connected) process.send?.({ kind, ...data });
 };
@@ -207,8 +201,7 @@ var RemotePeer = class {
   source = new rtc.nonstandard.RTCVideoSource({ isScreencast: true });
   track = this.source.createTrack();
   sender;
-  helper;
-  capture;
+  native;
   channels = /* @__PURE__ */ new Map();
   ready = false;
   ended = false;
@@ -239,7 +232,6 @@ var RemotePeer = class {
   legacy;
   quality;
   budget;
-  geometry;
   video;
   signal(raw) {
     let stage = "validation";
@@ -379,155 +371,54 @@ var RemotePeer = class {
     if (channel?.readyState === "open") channel.send(JSON.stringify({ ...value, remoteId: this.init.remoteId, revision: 1 }));
   }
   async startNative() {
-    if (process.platform === "linux") {
-      const displays = parseXrandr((await exec("xrandr", ["--listactivemonitors"], { timeout: 5e3 })).stdout);
-      if (this.ended) return;
-      const display = displays.find((d) => d.id === this.init.display.id);
-      if (!display || display.width !== this.init.display.width || display.height !== this.init.display.height) throw new Error("display");
-      this.geometry = { x: display.x, y: display.y, width: display.width, height: display.height };
-    }
     if (this.ended) return;
-    const child = nativeProcess(this.init.helper, this.init.display.id, this.video);
-    this.helper = child;
-    child.on("error", () => this.stop("\u4E3B\u673A\u8F93\u5165\u8F85\u52A9\u7A0B\u5E8F\u4E0D\u53EF\u7528"));
-    child.on("exit", () => {
-      if (this.helper === child) this.stop("\u4E3B\u673A\u6743\u9650\u3001\u663E\u793A\u5668\u6216\u56FE\u5F62\u4F1A\u8BDD\u5DF2\u53D8\u5316");
-    });
-    child.stdin?.on("error", () => this.stop("\u4E3B\u673A\u8F93\u5165\u8FDE\u63A5\u5DF2\u5173\u95ED"));
-    let lines = "";
-    child.stdout?.on("data", (chunk) => {
-      lines += String(chunk);
-      if (lines.length > 15e5) {
-        this.stop("\u4E3B\u673A\u526A\u8D34\u677F\u8D85\u8FC7\u4E0A\u9650");
-        return;
-      }
-      let end;
-      while ((end = lines.indexOf("\n")) >= 0) {
-        const line = lines.slice(0, end);
-        lines = lines.slice(end + 1);
-        try {
-          const message = JSON.parse(line);
-          if (message.kind === "clipboard" && typeof message.id === "string" && typeof message.data === "string") {
-            const callback = this.nativePending.get(message.id);
-            this.nativePending.delete(message.id);
-            callback?.(Buffer.from(message.data, "base64").toString("utf8"));
-          }
-          if (message.kind === "clipboard-written" && this.pendingClipboard?.id === message.id) {
-            this.pendingClipboard = void 0;
-            this.send("clipboard", { kind: "clipboard.done", id: message.id });
-          }
-          if (message.kind === "clipboard-error") {
-            if (typeof message.id === "string") this.nativePending.delete(message.id);
-            this.pendingClipboard = void 0;
-            this.send("clipboard", { kind: "clipboard.error", id: message.id, message: "\u4E3B\u673A\u526A\u8D34\u677F\u8BFB\u53D6\u5931\u8D25\u6216\u8D85\u8FC7 1 MiB" });
-          }
-          if (message.kind === "input-error") this.send("control", { kind: "input.error", message: "\u4E3B\u673A\u9501\u5C4F\u72B6\u6001\u5DF2\u53D8\u5316\uFF0C\u5DF2\u505C\u6B62\u8F93\u5165\u5BC6\u7801\uFF1B\u8BF7\u68C0\u67E5\u8FDC\u7AEF\u754C\u9762" });
-          if (message.kind === "error") this.stop("\u4E3B\u673A\u6743\u9650\u3001\u663E\u793A\u5668\u6216\u56FE\u5F62\u4F1A\u8BDD\u5DF2\u53D8\u5316");
-        } catch {
-          this.stop("\u4E3B\u673A\u8F85\u52A9\u7A0B\u5E8F\u8FD4\u56DE\u65E0\u6548\u6570\u636E");
-        }
-      }
-    });
-    if (process.platform === "darwin") this.macFrames(child.stdio[3]);
-    else {
-      const g = this.geometry;
-      this.writeNative(`geometry ${g.x} ${g.y} ${g.width} ${g.height}`);
-      this.linuxFrames();
-    }
-  }
-  macFrames(stream) {
-    let buffer = Buffer.alloc(0);
-    stream.on("data", (chunk) => {
-      if (this.ended) return;
-      buffer = Buffer.concat([buffer, chunk]);
-      if (buffer.length > REMOTE_DEFAULTS.maxWidth * REMOTE_DEFAULTS.maxHeight * 3 + 24) {
-        this.stop("\u8FDC\u63A7\u753B\u9762\u7F13\u51B2\u533A\u8D85\u9650");
-        return;
-      }
-      let latest;
-      while (buffer.length >= 12) {
-        const width = buffer.readUInt32BE(0), height = buffer.readUInt32BE(4), length = buffer.readUInt32BE(8);
-        if (!width || !height || width > REMOTE_DEFAULTS.maxWidth || height > REMOTE_DEFAULTS.maxHeight || width % 2 || height % 2 || length !== width * height * 1.5) {
-          this.stop("\u4E3B\u673A\u753B\u9762\u683C\u5F0F\u65E0\u6548");
-          return;
-        }
-        if (buffer.length < length + 12) break;
-        latest = { width, height, data: new Uint8Array(buffer.subarray(12, 12 + length)) };
-        buffer = buffer.subarray(12 + length);
-      }
-      if (latest && this.direct) {
-        this.firstFrameAt ||= Date.now();
-        this.frame(latest);
-      }
-    });
-  }
-  linuxFrames() {
-    const old = this.capture;
-    this.capture = void 0;
-    old?.kill("SIGTERM");
-    const g = this.geometry, { width, height, fps } = this.video;
-    const child = spawn(this.init.config.ffmpeg, ["-nostdin", "-hide_banner", "-loglevel", "error", "-f", "x11grab", "-framerate", String(fps), "-video_size", `${g.width}x${g.height}`, "-grab_x", String(g.x), "-grab_y", String(g.y), "-draw_mouse", "1", "-i", process.env.DISPLAY, "-vf", `scale=${width}:${height}`, "-pix_fmt", "yuv420p", "-f", "rawvideo", "pipe:1"], { stdio: ["ignore", "pipe", "ignore"] });
-    this.capture = child;
-    let buffer = Buffer.alloc(0);
-    const length = width * height * 1.5;
-    child.stdout.on("data", (chunk) => {
-      if (this.capture !== child || this.ended) return;
-      buffer = Buffer.concat([buffer, chunk]);
-      if (buffer.length > length * 4) {
-        this.stop("\u4E3B\u673A\u91C7\u96C6\u7F13\u51B2\u533A\u8D85\u9650");
-        return;
-      }
-      if (buffer.length >= length) {
-        const count = Math.floor(buffer.length / length), frame = buffer.subarray((count - 1) * length, count * length);
-        if (this.direct) {
+    const adapter = RemotePlatformRegistry.standard.resolve();
+    const error = adapter.platformError();
+    if (error) throw new Error(error);
+    const session = adapter.createSession({
+      helper: this.init.helper,
+      display: this.init.display,
+      video: this.video,
+      config: this.init.config,
+      onFrame: (frame) => {
+        if (!this.ended && this.direct) {
           this.firstFrameAt ||= Date.now();
-          this.frame({ width, height, data: new Uint8Array(frame) });
+          this.frame(frame);
         }
-        buffer = buffer.subarray(count * length);
-      }
-    });
-    child.on("error", () => this.stop("FFmpeg \u91C7\u96C6\u5931\u8D25"));
-    child.on("exit", () => {
-      if (this.capture === child) this.stop("\u663E\u793A\u5668\u5DF2\u53D8\u5316\u6216 FFmpeg \u91C7\u96C6\u5931\u8D25");
+      },
+      onMessage: (message) => {
+        if (!this.ended) this.nativeMessage(message);
+      },
+      onError: (message) => this.stop(message)
     });
+    this.native = session;
+    await session.start();
+  }
+  nativeMessage(message) {
+    if (message.kind === "clipboard" && typeof message.id === "string" && typeof message.data === "string") {
+      const callback = this.nativePending.get(message.id);
+      this.nativePending.delete(message.id);
+      callback?.(Buffer.from(message.data, "base64").toString("utf8"));
+    }
+    if (message.kind === "clipboard-written" && this.pendingClipboard?.id === message.id) {
+      this.pendingClipboard = void 0;
+      this.send("clipboard", { kind: "clipboard.done", id: message.id });
+    }
+    if (message.kind === "clipboard-error") {
+      if (typeof message.id === "string") this.nativePending.delete(message.id);
+      this.pendingClipboard = void 0;
+      this.send("clipboard", { kind: "clipboard.error", id: message.id, message: "\u4E3B\u673A\u526A\u8D34\u677F\u8BFB\u53D6\u5931\u8D25\u6216\u8D85\u8FC7 1 MiB" });
+    }
+    if (message.kind === "input-error") this.send("control", { kind: "input.error", message: "\u4E3B\u673A\u9501\u5C4F\u72B6\u6001\u5DF2\u53D8\u5316\uFF0C\u5DF2\u505C\u6B62\u8F93\u5165\u5BC6\u7801\uFF1B\u8BF7\u68C0\u67E5\u8FDC\u7AEF\u754C\u9762" });
   }
   frame(frame) {
     if (this.legacy || this.frameGate.accept(frame, Date.now())) this.source.onFrame(frame);
   }
   writeNative(line) {
-    if (!this.helper?.stdin || this.helper.stdin.destroyed) return;
-    if (this.helper.stdin.writableLength > 2 * 1024 * 1024) {
-      this.stop("\u4E3B\u673A\u8F93\u5165\u5904\u7406\u8D85\u65F6");
-      return;
-    }
-    this.helper.stdin.write(`${line}
-`);
+    this.native?.writeCommand(line);
   }
   input(input) {
-    switch (input.kind) {
-      case "pointer":
-        this.writeNative(`pointer ${input.x} ${input.y}`);
-        break;
-      case "button":
-        this.writeNative(`button ${input.x} ${input.y} ${input.button} ${input.down ? 1 : 0}`);
-        break;
-      case "wheel":
-        this.writeNative(`wheel ${input.x} ${input.y} ${Math.round(input.dx)} ${Math.round(input.dy)}`);
-        break;
-      case "key":
-        this.writeNative(`key ${input.code} ${input.down ? 1 : 0}`);
-        break;
-      case "password":
-        if (process.platform !== "darwin") return;
-        this.writeNative(`password ${Buffer.from(input.text).toString("base64")}`);
-        break;
-      case "text":
-        this.writeNative(`text ${input.terminal ? 1 : 0} ${Buffer.from(input.text).toString("base64")}`);
-        break;
-      case "release":
-        this.writeNative("release");
-        break;
-    }
+    this.native?.input(input);
   }
   clipboard(value) {
     if (typeof value.id !== "string" || !/^[a-zA-Z0-9_-]{1,64}$/.test(value.id)) throw new Error("clipboard id");
@@ -609,10 +500,7 @@ var RemotePeer = class {
     const video = this.budget.video(this.init.display.width, this.init.display.height);
     const changed = video.width !== this.video.width || video.height !== this.video.height || video.fps !== this.video.fps;
     this.video = video;
-    if (changed && this.ready) {
-      if (process.platform === "darwin") this.writeNative(`video ${video.width} ${video.height} ${video.fps}`);
-      else this.linuxFrames();
-    }
+    if (changed && this.ready) this.native?.setVideo(video);
   }
   async encoding() {
     if (this.parameterMode === "sdp") return;
@@ -677,9 +565,8 @@ var RemotePeer = class {
     clearInterval(this.timer);
     clearInterval(this.clipboardTimer);
     clearTimeout(this.handshake);
-    this.writeNative("release");
-    terminateNative(this.helper);
-    this.capture?.kill("SIGTERM");
+    this.native?.stop();
+    this.native = void 0;
     this.track.stop();
     for (const c of this.channels.values()) c.close();
     this.pc.close();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@skylandnpm/octopus-proxy",
-  "version": "0.1.65",
+  "version": "0.1.67",
   "type": "module",
   "description": "Octopus host proxy: OpenCode, Codex, ZCode and Pi adapters with service installer CLI",
   "bin": {