@skylandnpm/octopus-proxy 0.1.66 → 0.1.68

package/dist/{chunk-IV5ZGRAM.js → chunk-6G2W4KWC.js}

@@ -4,15 +4,16 @@ import {
   PlatformDesktop,
   REMOTE_DEFAULTS,
   RemoteConfigSchema,
+  RemotePlatformRegistry,
   RemoteQualitySchema,
   SignalSchema,
   __commonJS,
   __toESM,
   assertDirectSignal,
-  probeRemote,
+  nativeDependencies,
   remoteSessionBudget,
   z
-} from "./chunk-UFLXQ4HQ.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,18 +7813,22 @@ 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";
 import { promisify as promisify2 } from "node:util";
-import { realpath } from "node:fs/promises";
+import { realpath, stat as stat3 } from "node:fs/promises";
 import { relative, resolve } from "node:path";
 var execute = promisify2(execFile2);
 var MAX_PATCH = 256 * 1024;
 var MAX_TOTAL = 1024 * 1024;
-async function workspaceDiff(workspace, project) {
+var MAX_LINES = 2e3;
+async function workspaceDiff(workspace, project, page = {}) {
+  const offset = page.paged ? page.offset ?? 0 : 0;
+  const limit = page.paged ? page.limit ?? 20 : 200;
+  if (!Number.isSafeInteger(offset) || offset < 0 || !Number.isSafeInteger(limit) || limit < 1 || limit > 200) throw new Error("Invalid diff page");
   const root = await workspace.root(project);
   const git = async (...args) => (await execute("git", ["--no-optional-locks", "-c", "core.quotePath=false", ...args], {
     cwd: root,
@@ -7867,13 +7872,8 @@ async function workspaceDiff(workspace, project) {
   if (!base) throw new Error("\u65E0\u6CD5\u8BFB\u53D6 Git \u6BD4\u8F83\u57FA\u51C6");
   const files = [];
   let bytes = 0;
-  for (const entry of entries.slice(0, 200)) {
+  for (const entry of entries.slice(offset, offset + limit)) {
     const change = { ...entry, patch: "", additions: 0, deletions: 0 };
-    if (bytes >= MAX_TOTAL) {
-      change.notice = "\u53D8\u66F4\u8F83\u591A\uFF0C\u672A\u52A0\u8F7D\u6B64\u6587\u4EF6\u5185\u5BB9";
-      files.push(change);
-      continue;
-    }
     try {
       if (entry.status === "??") {
         const read = await workspace.read(project, entry.file, 0, MAX_PATCH);
@@ -7890,16 +7890,30 @@ ${lines.map((line) => `+${line}`).join("\n")}
 `;
         }
       } else {
-        change.patch = await git("diff", "--no-ext-diff", "--no-textconv", "--no-renames", "--no-color", "--relative", "--unified=3", base, "--", entry.file);
-        change.binary = change.patch.includes("Binary files ");
-        if (Buffer.byteLength(change.patch) > MAX_PATCH) {
-          change.patch = "";
-          change.notice = "\u5DEE\u5F02\u8FC7\u5927\uFF0C\u8BF7\u5728\u672C\u5730 Git \u67E5\u770B";
+        let currentSize = 0, baseSize = 0;
+        try {
+          currentSize = (await stat3(await workspace.path(project, entry.file))).size;
+        } catch (error) {
+          if (error.code !== "ENOENT") throw error;
+        }
+        try {
+          baseSize = Number((await git("cat-file", "-s", `${base}:${prefix ? `${prefix}/` : ""}${entry.file}`)).trim());
+        } catch {
+        }
+        if (Math.max(currentSize, baseSize) > MAX_PATCH) change.notice = "\u6587\u4EF6\u8D85\u8FC7 256 KiB\uFF0C\u672A\u52A0\u8F7D\u5DEE\u5F02\uFF0C\u8BF7\u5728\u6587\u4EF6\u9762\u677F\u6216\u672C\u5730 Git \u67E5\u770B";
+        else {
+          change.patch = await git("diff", "--no-ext-diff", "--no-textconv", "--no-renames", "--no-color", "--relative", "--unified=3", base, "--", entry.file);
+          change.binary = change.patch.includes("Binary files ");
         }
       }
     } catch (error) {
       change.notice = error instanceof Error ? error.message.slice(0, 250) : "\u65E0\u6CD5\u52A0\u8F7D\u6587\u4EF6\u5DEE\u5F02";
     }
+    if (Buffer.byteLength(change.patch) > MAX_PATCH || change.patch.split("\n").length > MAX_LINES) {
+      change.patch = "";
+      change.notice = "\u5DEE\u5F02\u8D85\u8FC7 256 KiB \u6216 2000 \u884C\uFF0C\u672A\u52A0\u8F7D\u5DEE\u5F02\uFF0C\u8BF7\u5728\u672C\u5730 Git \u67E5\u770B";
+    }
+    if (bytes + Buffer.byteLength(change.patch) > MAX_TOTAL) break;
     let inHunk = false;
     for (const line of change.patch.split("\n")) {
       if (line.startsWith("@@ ")) inHunk = true;
@@ -7909,12 +7923,13 @@ ${lines.map((line) => `+${line}`).join("\n")}
     bytes += Buffer.byteLength(change.patch);
     files.push(change);
   }
-  return { scope: "workspace", files, total: entries.length, truncated: entries.length > 200 || files.some((file) => file.notice), directory: prefix || ".", capturedAt: Date.now() };
+  const nextOffset = offset + files.length < entries.length ? offset + files.length : void 0;
+  return { scope: "workspace", files, total: entries.length, nextOffset, truncated: nextOffset !== void 0 || files.some((file) => file.notice), directory: prefix || ".", capturedAt: Date.now() };
 }
 
 // src/workspace.ts
 import { constants } from "node:fs";
-import { mkdir as mkdir2, open as open2, readdir, realpath as realpath2, stat as stat3, link, unlink as unlink3 } from "node:fs/promises";
+import { mkdir as mkdir2, open as open2, readdir, realpath as realpath2, stat as stat4, link, unlink as unlink3 } from "node:fs/promises";
 import { basename, dirname, extname, isAbsolute as isAbsolute2, relative as relative2, resolve as resolve2, sep } from "node:path";
 import { createHash as createHash2 } from "node:crypto";
 var mimeOf = (name) => ({ ".png": "image/png", ".jpg": "image/jpeg", ".jpeg": "image/jpeg", ".gif": "image/gif", ".webp": "image/webp", ".svg": "image/svg+xml", ".md": "text/markdown", ".txt": "text/plain", ".json": "application/json", ".pdf": "application/pdf" })[extname(name).toLowerCase()] ?? "application/octet-stream";
@@ -7949,7 +7964,7 @@ var Workspace = class {
       const name = relative2(await this.root(id), resolve2(full, e.name));
       try {
         const safe = await this.path(id, name);
-        const info = await stat3(safe);
+        const info = await stat4(safe);
         return { name: e.name, path: name, type: info.isDirectory() ? "directory" : "file", size: info.size };
       } catch {
         return null;
@@ -8046,7 +8061,7 @@ var Workspace = class {
 
 // src/uploads.ts
 import { constants as constants2 } from "node:fs";
-import { open as open3, readdir as readdir2, unlink as unlink4, stat as stat4 } from "node:fs/promises";
+import { open as open3, readdir as readdir2, unlink as unlink4, stat as stat5 } from "node:fs/promises";
 import { basename as basename2, dirname as dirname3, join as join4 } from "node:path";
 import { createHash as createHash3, randomUUID as randomUUID4 } from "node:crypto";
 
@@ -8105,7 +8120,7 @@ var Uploads = class {
     if (!u || u.projectId !== projectId) throw new Error("Upload not found in this project");
     if (u.state === "pending" && u.offset === u.size) {
       try {
-        await stat4(u.temp);
+        await stat5(u.temp);
       } catch (e) {
         if (e.code !== "ENOENT") throw e;
         const target = await this.workspace.path(projectId, u.destination);
@@ -8130,7 +8145,7 @@ var Uploads = class {
     } else destination = `${String(input.directory ?? ".")}/${name}`;
     const dest = await this.workspace.path(projectId, destination, true);
     try {
-      await stat4(dest);
+      await stat5(dest);
       throw new Error("Destination exists; rename the file");
     } catch (e) {
       if (e.code !== "ENOENT") throw e;
@@ -8513,7 +8528,7 @@ function pageHistory(input, payload) {
 // src/artifacts.ts
 import { createHash as createHash5 } from "node:crypto";
 import { join as join6 } from "node:path";
-import { readFile as readFile4, writeFile as writeFile3, mkdir as mkdir4, stat as stat5 } from "node:fs/promises";
+import { readFile as readFile4, writeFile as writeFile3, mkdir as mkdir4, stat as stat6 } from "node:fs/promises";
 var Artifacts = class {
   constructor(workspace, directory, emit) {
     this.workspace = workspace;
@@ -8537,6 +8552,12 @@ var Artifacts = class {
   scan(project) {
     return this.serial(project, () => this.scanUnlocked(project));
   }
+  async scanPage(project, offset = 0, limit = 20) {
+    if (!Number.isSafeInteger(offset) || offset < 0 || !Number.isSafeInteger(limit) || limit < 1 || limit > 200) throw new Error("Invalid artifact page");
+    const all = (await this.scan(project)).sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0);
+    const items = all.slice(offset, offset + limit).map((item) => ({ ...item, revisions: item.revisions.slice(-1) }));
+    return { items, total: all.length, nextOffset: offset + items.length < all.length ? offset + items.length : void 0 };
+  }
   async scanUnlocked(project) {
     await this.workspace.root(project);
     const index = await readJson(this.index(project)) ?? {}, seen = /* @__PURE__ */ new Set();
@@ -8585,7 +8606,7 @@ var Artifacts = class {
     }
     for (const item of Object.values(index)) if (!seen.has(item.path) && !item.revisions.at(-1)?.deleted) {
       try {
-        await stat5(await this.workspace.path(project, item.path));
+        await stat6(await this.workspace.path(project, item.path));
       } catch (e) {
         if (e.code === "ENOENT") {
           item.revisions.push({ hash: "", timestamp: (/* @__PURE__ */ new Date()).toISOString(), deleted: true });
@@ -8596,7 +8617,7 @@ var Artifacts = class {
     }
     if (changed) {
       await atomicJson(this.index(project), index);
-      this.emit(project, "artifacts.updated", Object.values(index));
+      this.emit(project, "artifacts.updated", { total: Object.keys(index).length });
     }
     return Object.values(index);
   }
@@ -8607,6 +8628,14 @@ var Artifacts = class {
     if (!/^[a-f0-9]{64}$/.test(hash) || !(await this.history(project, path)).some((r) => r.hash === hash)) throw new Error("Unknown revision");
     return readFile4(join6(this.directory, project, "blobs", hash), "utf8");
   }
+  async preview(project, path, hash) {
+    if (!/^[a-f0-9]{64}$/.test(hash) || !(await this.history(project, path)).some((r) => r.hash === hash)) throw new Error("Unknown revision");
+    const blob = join6(this.directory, project, "blobs", hash);
+    if ((await stat6(blob)).size > 256 * 1024) return { content: "", notice: "\u6587\u4EF6\u8D85\u8FC7 256 KiB\uFF0C\u5DF2\u8DF3\u8FC7\u9884\u89C8\uFF0C\u8BF7\u5728\u6587\u4EF6\u9762\u677F\u6216\u672C\u5730\u67E5\u770B\u3002" };
+    const content = await readFile4(blob, "utf8");
+    if (content.split("\n").length > 2e3) return { content: "", notice: "\u6587\u4EF6\u8D85\u8FC7 2000 \u884C\uFF0C\u5DF2\u8DF3\u8FC7\u9884\u89C8\uFF0C\u8BF7\u5728\u6587\u4EF6\u9762\u677F\u6216\u672C\u5730\u67E5\u770B\u3002" };
+    return { content };
+  }
   associate(project, path, sessionId) {
     return this.serial(project, () => this.associateUnlocked(project, path, sessionId));
   }
@@ -8628,7 +8657,7 @@ import { TLSSocket, createSecureContext } from "node:tls";
 
 // src/host-auth.ts
 import { spawn } from "node:child_process";
-import { chmod as chmod3, mkdir as mkdir5, rename as rename3, stat as stat6, unlink as unlink5 } from "node:fs/promises";
+import { chmod as chmod3, mkdir as mkdir5, rename as rename3, stat as stat7, unlink as unlink5 } from "node:fs/promises";
 import { userInfo, platform as platform2 } from "node:os";
 import { randomUUID as randomUUID6 } from "node:crypto";
 import { join as join7 } from "node:path";
@@ -8643,8 +8672,8 @@ async function ensureHostAuth(stateDirectory) {
   if (system !== "darwin" && system !== "linux") throw new Error("Host authentication is supported only on macOS and Linux");
   const mac = system === "darwin";
   const source = fileURLToPath2(new URL(mac ? "../native/auth-macos.m" : "../native/auth-linux.c", import.meta.url));
-  const sourceInfo = await stat6(source);
-  const existing = await stat6(target).catch(() => null);
+  const sourceInfo = await stat7(source);
+  const existing = await stat7(target).catch(() => null);
   if (existing?.isFile() && existing.mtimeMs >= sourceInfo.mtimeMs && (existing.mode & 63) === 0) return target;
   const temporary = `${target}.${randomUUID6()}`;
   const args = mac ? ["-O2", "-framework", "Foundation", "-framework", "OpenDirectory", source, "-o", target] : ["-O2", source, "-o", temporary, "-lpam"];
@@ -13617,7 +13646,7 @@ function createAdapter(runtime, workspace, uploads, emit) {
 }
 
 // src/project-registry.ts
-import { realpath as realpath6, readFile as readFile9, stat as stat7 } from "node:fs/promises";
+import { realpath as realpath6, readFile as readFile9, stat as stat8 } from "node:fs/promises";
 import { isAbsolute as isAbsolute4 } from "node:path";
 import { isDeepStrictEqual } from "node:util";
 var ProjectMutationSchema = ProjectSchema.extend({
@@ -13705,7 +13734,7 @@ var ProjectRegistry = class {
     const raw = await this.readCurrent();
     const directory = expandHome(parsed.directory);
     if (!isAbsolute4(directory)) throw new Error("\u9879\u76EE\u76EE\u5F55\u5FC5\u987B\u662F Proxy \u4E3B\u673A\u4E0A\u7684\u7EDD\u5BF9\u8DEF\u5F84");
-    const info = await stat7(directory).catch(() => void 0);
+    const info = await stat8(directory).catch(() => void 0);
     if (!info?.isDirectory()) throw new Error(`\u9879\u76EE\u76EE\u5F55\u4E0D\u5B58\u5728\u6216\u4E0D\u662F\u76EE\u5F55\uFF1A${directory}`);
     const canonical = await realpath6(directory);
     if (this.config.projects.some((project2) => project2.id === parsed.id)) throw new Error(`\u9879\u76EE ID \u5DF2\u5B58\u5728\uFF1A${parsed.id}`);
@@ -13724,7 +13753,7 @@ var ProjectRegistry = class {
     if (index < 0) throw new Error(`\u672A\u77E5\u6388\u6743\u9879\u76EE\uFF1A${parsed.id}`);
     const directory = expandHome(parsed.directory);
     if (!isAbsolute4(directory)) throw new Error("\u9879\u76EE\u76EE\u5F55\u5FC5\u987B\u662F Proxy \u4E3B\u673A\u4E0A\u7684\u7EDD\u5BF9\u8DEF\u5F84");
-    const info = await stat7(directory).catch(() => void 0);
+    const info = await stat8(directory).catch(() => void 0);
     if (!info?.isDirectory()) throw new Error(`\u9879\u76EE\u76EE\u5F55\u4E0D\u5B58\u5728\u6216\u4E0D\u662F\u76EE\u5F55\uFF1A${directory}`);
     const canonical = await realpath6(directory);
     for (const project of this.config.projects) {
@@ -13755,7 +13784,7 @@ var ProjectRegistry = class {
 
 // src/terminal.ts
 import { randomUUID as randomUUID17 } from "node:crypto";
-import { access as access2, stat as stat9 } from "node:fs/promises";
+import { access as access2, stat as stat10 } from "node:fs/promises";
 import { constants as constants5 } from "node:fs";
 import { platform as platform3, userInfo as userInfo3 } from "node:os";
 import { delimiter } from "node:path";
@@ -13763,7 +13792,7 @@ import * as pty from "node-pty";
 
 // src/terminal-support.ts
 import { createRequire } from "node:module";
-import { access, chmod as chmod4, stat as stat8 } from "node:fs/promises";
+import { access, chmod as chmod4, stat as stat9 } from "node:fs/promises";
 import { constants as constants4 } from "node:fs";
 import { dirname as dirname6, resolve as resolve4 } from "node:path";
 var require2 = createRequire(import.meta.url);
@@ -13773,7 +13802,7 @@ function terminalHelperPath() {
   return resolve4(dirname6(utilsPath), native.dir, "spawn-helper");
 }
 async function prepareTerminalHelper(path, fix) {
-  const info = await stat8(path);
+  const info = await stat9(path);
   if (!info.isFile()) throw new Error(`\u7EC8\u7AEF\u8F85\u52A9\u7A0B\u5E8F\u4E0D\u662F\u666E\u901A\u6587\u4EF6\uFF1A${path}`);
   try {
     await access(path, constants4.X_OK);
@@ -13832,7 +13861,7 @@ var TerminalManager = class {
       const count = [...this.terminals.values()].filter((t) => t.owner === owner).length;
       if (count >= 8) throw new Error("Terminal limit reached");
       const cwd = await this.workspace.path(project, typeof p.cwd === "string" ? p.cwd : ".");
-      if (!(await stat9(cwd)).isDirectory()) throw new Error(`\u7EC8\u7AEF\u5DE5\u4F5C\u76EE\u5F55\u4E0D\u662F\u76EE\u5F55\uFF1A${cwd}`);
+      if (!(await stat10(cwd)).isDirectory()) throw new Error(`\u7EC8\u7AEF\u5DE5\u4F5C\u76EE\u5F55\u4E0D\u662F\u76EE\u5F55\uFF1A${cwd}`);
       const shell = process.env.SHELL || (platform3() === "darwin" ? "/bin/zsh" : "/bin/sh");
       try {
         await access2(shell, constants5.X_OK);
@@ -13959,8 +13988,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 stat11, 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 stat11(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";
@@ -14027,13 +14097,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;
@@ -14042,23 +14112,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;
+      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: 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" } : {} };
+      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" };
     }
@@ -14094,15 +14166,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");
@@ -14173,16 +14246,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 stat12 } 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"]);
@@ -14226,15 +14299,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 stat12(full);
       if (info.isFile() && info.mode & 73) return full;
     } catch {
     }
@@ -14317,7 +14390,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 : {};
@@ -14359,7 +14432,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();
@@ -14376,8 +14449,8 @@ 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);
@@ -14399,7 +14472,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);
   });
@@ -14444,7 +14517,7 @@ async function runDaemon(configPath, authenticate = verifyHostPassword) {
     workspace.project(project);
     if (c.operation === "workspace.list") return p.paged === true ? workspace.listPage(project, String(p.path ?? "."), p.cursor === void 0 ? "" : p.cursor, p.limit === void 0 ? 200 : Number(p.limit)) : workspace.list(project, String(p.path ?? "."));
     if (c.operation === "workspace.read") return workspace.read(project, String(p.path), Number(p.offset ?? 0), Number(p.length ?? 512 * 1024));
-    if (c.operation === "workspace.diff") return workspaceDiff(workspace, project);
+    if (c.operation === "workspace.diff") return workspaceDiff(workspace, project, { paged: p.paged === true, offset: Number(p.offset ?? 0), limit: Number(p.limit ?? 20) });
     if (c.operation === "workspace.search") return workspace.search(project, String(p.query));
     if (c.operation === "workspace.write") return workspace.write(project, String(p.path), String(p.content), String(p.expectedHash));
     if (c.operation === "uploads.init") {
@@ -14458,9 +14531,9 @@ async function runDaemon(configPath, authenticate = verifyHostPassword) {
     if (c.operation === "uploads.chunk") return uploads.chunk(project, String(p.id), Number(p.offset), String(p.data));
     if (c.operation === "uploads.complete") return uploads.complete(project, String(p.id));
     if (c.operation === "uploads.cancel") return uploads.cancel(project, String(p.id));
-    if (c.operation === "artifacts.list") return artifacts.scan(project);
+    if (c.operation === "artifacts.list") return p.paged === true ? artifacts.scanPage(project, Number(p.offset ?? 0), Number(p.limit ?? 20)) : artifacts.scan(project);
     if (c.operation === "artifacts.history") return artifacts.history(project, String(p.path));
-    if (c.operation === "artifacts.read") return artifacts.read(project, String(p.path), String(p.hash));
+    if (c.operation === "artifacts.read") return p.preview === true ? artifacts.preview(project, String(p.path), String(p.hash)) : artifacts.read(project, String(p.path), String(p.hash));
     if (c.operation === "artifacts.associate") {
       if (!c.sessionId) throw new Error("Session required");
       await adapter.session(project, c.sessionId);

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

@@ -4449,66 +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 remotePlatformError(system = process.platform, arch = process.arch, env = process.env) {
-  if (!["darwin", "linux"].includes(system) || !["arm64", "x64"].includes(arch)) return `\u8FDC\u63A7\u4E0D\u652F\u6301\u5F53\u524D\u5E73\u53F0 ${system}/${arch}\uFF1B\u9700\u8981 macOS 12.3+ \u6216 Linux X11\uFF08x64/ARM64\uFF09`;
-  if (system === "linux") {
-    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";
-  }
-}
-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) {
-  const platformError = remotePlatformError();
-  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);
-  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;
@@ -4519,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,
@@ -4539,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-IV5ZGRAM.js";
+} from "./chunk-6G2W4KWC.js";
 import {
   DESKTOP_PERMISSION_GUIDANCE,
   PlatformDesktop,
   checkDesktop,
   requestDesktopPermission
-} from "./chunk-UFLXQ4HQ.js";
+} from "./chunk-OTKNRBZ7.js";
 
 // src/cli.ts
 import { spawn as spawn2 } from "node:child_process";

package/dist/main.js

@@ -2,8 +2,8 @@
 import {
   ConfigError,
   runDaemon
-} from "./chunk-IV5ZGRAM.js";
-import "./chunk-UFLXQ4HQ.js";
+} from "./chunk-6G2W4KWC.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-UFLXQ4HQ.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.66",
+  "version": "0.1.68",
   "type": "module",
   "description": "Octopus host proxy: OpenCode, Codex, ZCode and Pi adapters with service installer CLI",
   "bin": {