@skylandnpm/octopus-proxy 0.1.35 → 0.1.38

package/dist/{chunk-5OJQ46AF.js → chunk-6DTK4JVV.js}

@@ -11714,8 +11714,8 @@ async function ensureHostIdentity(stateDirectory) {
 }
 
 // src/daemon.ts
-import { mkdir as mkdir10 } from "node:fs/promises";
-import { join as join13 } from "node:path";
+import { mkdir as mkdir11 } from "node:fs/promises";
+import { join as join14 } from "node:path";
 
 // src/workspace-diff.ts
 import { execFile as execFile2 } from "node:child_process";
@@ -12186,7 +12186,7 @@ function isAuthentication(operation) {
 }
 
 // src/journal.ts
-import { join as join4 } from "node:path";
+import { join as join6 } from "node:path";
 import { createHash as createHash4 } from "node:crypto";
 
 // ../../packages/protocol/src/index.ts
@@ -12250,6 +12250,8 @@ var Operations = [
   "desktop.list",
   "desktop.capture",
   "desktop.read",
+  "desktop.lockStatus",
+  "desktop.unlock",
   "artifacts.list",
   "artifacts.history",
   "artifacts.read",
@@ -12271,6 +12273,252 @@ var CommandSchema = z.object({
 }).strict();
 var isReadOperation = (operation) => operation === "desktop.capture" || /\.(status|snapshot|list|get|messages|diff|todos|children|logs|projects|read|search|history|models|agents|commands|providers|mcp)$/.test(operation);
 
+// src/screen-lock.ts
+import { spawn as spawn2 } from "node:child_process";
+import { chmod as chmod3, mkdir as mkdir5, rename as rename4, rm, stat as stat6 } from "node:fs/promises";
+import { randomUUID as randomUUID7 } from "node:crypto";
+import { userInfo as userInfo2 } from "node:os";
+import { join as join5 } from "node:path";
+import { fileURLToPath as fileURLToPath3 } from "node:url";
+import { setTimeout as delay } from "node:timers/promises";
+
+// src/host-auth.ts
+import { spawn } from "node:child_process";
+import { chmod as chmod2, mkdir as mkdir4, rename as rename3, stat as stat5, unlink as unlink4 } from "node:fs/promises";
+import { userInfo, platform as platform2 } from "node:os";
+import { randomUUID as randomUUID6 } from "node:crypto";
+import { join as join4 } from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+function helperPath(stateDirectory) {
+  return join4(stateDirectory, "octopus-host-auth");
+}
+async function ensureHostAuth(stateDirectory) {
+  await mkdir4(stateDirectory, { recursive: true, mode: 448 });
+  const target = helperPath(stateDirectory);
+  const system = platform2();
+  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 stat5(source);
+  const existing = await stat5(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"];
+  if (mac) args[args.length - 1] = temporary;
+  const compiler = spawn(mac ? "clang" : "cc", args, { stdio: ["ignore", "ignore", "pipe"] });
+  let diagnostics = "";
+  compiler.stderr.on("data", (chunk) => {
+    diagnostics += String(chunk).slice(0, 4096);
+  });
+  const exit = await new Promise((resolve4, reject) => {
+    compiler.on("error", reject);
+    compiler.on("exit", (code) => resolve4(code ?? 1));
+  });
+  if (exit !== 0) {
+    await unlink4(temporary).catch(() => {
+    });
+    throw new Error(`Host authentication helper build failed: ${diagnostics.trim()}`);
+  }
+  try {
+    await chmod2(temporary, 448);
+    await rename3(temporary, target);
+    return target;
+  } finally {
+    await unlink4(temporary).catch(() => {
+    });
+  }
+}
+async function verifyHostPassword(stateDirectory, username, password) {
+  if (username !== userInfo().username || !password || Buffer.byteLength(password) > 1024) return false;
+  const path = await ensureHostAuth(stateDirectory);
+  const child = spawn(path, [], { stdio: ["pipe", "pipe", "ignore"] });
+  const bytes = Buffer.from(password, "utf8");
+  const header2 = Buffer.alloc(2);
+  header2.writeUInt16BE(bytes.length);
+  child.stdin.end(Buffer.concat([header2, bytes]));
+  bytes.fill(0);
+  let output = "";
+  child.stdout.on("data", (chunk) => {
+    output += String(chunk).slice(0, 16);
+  });
+  const timer = setTimeout(() => child.kill("SIGKILL"), 1e4);
+  try {
+    const code = await new Promise((resolve4, reject) => {
+      child.on("error", reject);
+      child.on("exit", (value) => resolve4(value ?? 1));
+    });
+    return code === 0 && output.trim() === "OK";
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+// src/screen-lock.ts
+var ScreenLockError = class extends Error {
+};
+var nativeErrors = {
+  permission: "\u8BF7\u5728 Proxy \u4E3B\u673A\u201C\u7CFB\u7EDF\u8BBE\u7F6E \u2192 \u9690\u79C1\u4E0E\u5B89\u5168\u6027 \u2192 \u8F85\u52A9\u529F\u80FD\u201D\u4E2D\u6388\u6743\u5B9E\u9645\u8FD0\u884C Proxy \u7684\u7A0B\u5E8F\uFF0C\u5E76\u91CD\u542F Proxy\u3002",
+  session: "\u65E0\u6CD5\u8BBF\u95EE Proxy \u7528\u6237\u7684\u6D3B\u52A8\u56FE\u5F62\u4F1A\u8BDD\uFF1B\u4E0D\u652F\u6301\u767B\u5F55\u524D\u3001FileVault \u542F\u52A8\u89E3\u9501\u6216\u5207\u6362\u5230\u5176\u4ED6\u7528\u6237\u7684\u5C4F\u5E55\u3002",
+  focus: "\u672A\u627E\u5230 loginwindow \u7684\u5BC6\u7801\u8F93\u5165\u6846\uFF0C\u8BF7\u5728\u4E3B\u673A\u663E\u793A\u5F53\u524D\u7528\u6237\u7684\u5BC6\u7801\u89E3\u9501\u754C\u9762\u540E\u91CD\u8BD5\u3002",
+  changed: "\u4E3B\u673A\u9501\u5C4F\u72B6\u6001\u6216\u5BC6\u7801\u8F93\u5165\u7126\u70B9\u5DF2\u53D8\u5316\uFF0C\u5DF2\u505C\u6B62\u8F93\u5165\uFF0C\u8BF7\u91CD\u8BD5\u3002",
+  timeout: "\u4E3B\u673A\u5C4F\u5E55\u4ECD\u9501\u5B9A\uFF0C\u7CFB\u7EDF\u672A\u63A5\u53D7\u89E3\u9501\u8F93\u5165\uFF1B\u8BF7\u68C0\u67E5\u8F85\u52A9\u529F\u80FD\u6743\u9650\u548C\u9501\u5C4F\u754C\u9762\u540E\u91CD\u8BD5\u3002",
+  password: "\u4E3B\u673A\u5BC6\u7801\u683C\u5F0F\u65E0\u6548\u3002"
+};
+var executeScreenLock = (file, args, input, signal) => new Promise((resolve4, reject) => {
+  if (signal?.aborted) {
+    reject(new ScreenLockError("\u8FDE\u63A5\u5DF2\u5173\u95ED\uFF0C\u5C4F\u5E55\u89E3\u9501\u5DF2\u53D6\u6D88\u3002"));
+    return;
+  }
+  const child = spawn2(file, args, { stdio: ["pipe", "pipe", "pipe"], signal });
+  let output = "", diagnostic = "", timedOut = false;
+  const timer = setTimeout(() => {
+    timedOut = true;
+    child.kill("SIGKILL");
+  }, args[0] === "unlock" ? 45e3 : 15e3);
+  child.stdout.on("data", (chunk) => {
+    output += String(chunk);
+    if (output.length > 4096) child.kill("SIGKILL");
+  });
+  child.stderr.on("data", (chunk) => {
+    diagnostic = (diagnostic + String(chunk)).slice(0, 4096);
+  });
+  child.stdin.on("error", () => {
+  });
+  child.on("error", () => {
+    clearTimeout(timer);
+    reject(new ScreenLockError(signal?.aborted ? "\u8FDE\u63A5\u5DF2\u5173\u95ED\uFF0C\u5C4F\u5E55\u89E3\u9501\u5DF2\u53D6\u6D88\u3002" : "\u5C4F\u5E55\u89E3\u9501\u4F9D\u8D56\u4E0D\u53EF\u7528\uFF1BmacOS \u9700\u8981 Xcode Command Line Tools\uFF0CLinux \u9700\u8981 systemd loginctl\u3002"));
+  });
+  child.on("close", (code) => {
+    clearTimeout(timer);
+    if (signal?.aborted) reject(new ScreenLockError("\u8FDE\u63A5\u5DF2\u5173\u95ED\uFF0C\u5C4F\u5E55\u89E3\u9501\u5DF2\u53D6\u6D88\u3002"));
+    else if (code !== 0 || output.length > 4096) reject(new ScreenLockError(timedOut ? "\u5C4F\u5E55\u89E3\u9501\u64CD\u4F5C\u8D85\u65F6\uFF0C\u8BF7\u68C0\u67E5\u4E3B\u673A\u72B6\u6001\u540E\u91CD\u8BD5\u3002" : nativeErrors[diagnostic.trim()] ?? "\u5C4F\u5E55\u89E3\u9501\u64CD\u4F5C\u5931\u8D25\uFF0C\u8BF7\u68C0\u67E5\u4E3B\u673A\u7684\u56FE\u5F62\u4F1A\u8BDD\u3001\u7CFB\u7EDF\u6743\u9650\u53CA\u4F9D\u8D56\u3002"));
+    else resolve4(output);
+  });
+  child.stdin.end(input);
+});
+var PlatformScreenLock = class {
+  constructor(stateDirectory, system = process.platform, environment = process.env, execute3 = executeScreenLock, authenticate = verifyHostPassword, account = userInfo2()) {
+    this.stateDirectory = stateDirectory;
+    this.system = system;
+    this.environment = environment;
+    this.execute = execute3;
+    this.authenticate = authenticate;
+    this.account = account;
+  }
+  helper;
+  failures = 0;
+  blockedUntil = 0;
+  macHelper() {
+    if (this.helper) return this.helper;
+    this.helper = (async () => {
+      await mkdir5(this.stateDirectory, { recursive: true, mode: 448 });
+      const target = join5(this.stateDirectory, "octopus-screen-unlock");
+      const source = fileURLToPath3(new URL("../native/screen-unlock-macos.m", import.meta.url));
+      const sourceInfo = await stat6(source), existing = await stat6(target).catch(() => null);
+      if (existing?.isFile() && existing.mtimeMs >= sourceInfo.mtimeMs && (existing.mode & 63) === 0) return target;
+      const temporary = `${target}.${randomUUID7()}`;
+      try {
+        await this.execute("/usr/bin/clang", ["-O2", "-fobjc-arc", "-mmacosx-version-min=12.3", "-framework", "Foundation", "-framework", "AppKit", "-framework", "ApplicationServices", source, "-o", temporary]);
+        await chmod3(temporary, 448);
+        await rename4(temporary, target);
+        return target;
+      } finally {
+        await rm(temporary, { force: true });
+      }
+    })();
+    this.helper.catch(() => {
+      this.helper = void 0;
+    });
+    return this.helper;
+  }
+  async linuxSession(signal) {
+    let ids;
+    if (this.environment.XDG_SESSION_ID) ids = [this.environment.XDG_SESSION_ID];
+    else ids = (await this.execute("loginctl", ["--no-ask-password", "list-sessions", "--no-legend"], void 0, signal)).trim().split("\n").map((line) => line.trim().split(/\s+/)[0]).filter(Boolean);
+    const sessions = [];
+    for (const id of ids) {
+      if (!/^[a-zA-Z0-9_-]+$/.test(id)) continue;
+      const text = await this.execute("loginctl", ["--no-ask-password", "show-session", id, "-p", "User", "-p", "Type", "-p", "Active", "-p", "LockedHint"], void 0, signal);
+      const properties = Object.fromEntries(text.trim().split("\n").map((line) => line.split("=")));
+      if (properties.User !== String(this.account.uid) || !["x11", "wayland"].includes(properties.Type) || properties.Active !== "yes") continue;
+      if (!["yes", "no"].includes(properties.LockedHint)) throw new ScreenLockError("\u684C\u9762\u672A\u62A5\u544A\u6709\u6548\u7684\u9501\u5C4F\u72B6\u6001\uFF0C\u65E0\u6CD5\u786E\u8BA4\u89E3\u9501\u3002");
+      sessions.push({ id, locked: properties.LockedHint === "yes" });
+    }
+    if (sessions.length !== 1) throw new ScreenLockError("\u65E0\u6CD5\u786E\u5B9A Proxy \u7528\u6237\u7684\u552F\u4E00\u6D3B\u52A8\u56FE\u5F62\u4F1A\u8BDD\uFF0C\u8BF7\u8BBE\u7F6E\u6B63\u786E\u7684 XDG_SESSION_ID\u3002");
+    return sessions[0];
+  }
+  parseStatus(text) {
+    let data;
+    try {
+      data = JSON.parse(text);
+    } catch {
+      throw new ScreenLockError("\u4E3B\u673A\u8FD4\u56DE\u7684\u9501\u5C4F\u72B6\u6001\u65E0\u6548\u3002");
+    }
+    if (!data || typeof data.locked !== "boolean" || typeof data.canUnlock !== "boolean") throw new ScreenLockError("\u4E3B\u673A\u8FD4\u56DE\u7684\u9501\u5C4F\u72B6\u6001\u65E0\u6548\u3002");
+    return { locked: data.locked, canUnlock: data.canUnlock, account: this.account.username, ...!data.canUnlock ? { message: nativeErrors.permission } : {} };
+  }
+  async status() {
+    if (this.system === "darwin") return this.parseStatus(await this.execute(await this.macHelper(), ["status"]));
+    if (this.system === "linux") return { locked: (await this.linuxSession()).locked, canUnlock: true, account: this.account.username };
+    throw new ScreenLockError("\u5C4F\u5E55\u89E3\u9501\u4EC5\u652F\u6301 macOS 12.3 \u53CA\u4EE5\u4E0A\u548C\u4F7F\u7528 systemd \u7684 Linux \u56FE\u5F62\u4F1A\u8BDD\u3002");
+  }
+  async unlock(password, signal) {
+    const check = () => {
+      if (signal.aborted) throw new ScreenLockError("\u8FDE\u63A5\u5DF2\u5173\u95ED\uFF0C\u5C4F\u5E55\u89E3\u9501\u5DF2\u53D6\u6D88\u3002");
+    };
+    check();
+    if (!password || Buffer.byteLength(password) > 1024 || /[\x00-\x1f\x7f]/.test(password)) throw new ScreenLockError("\u4E3B\u673A\u5BC6\u7801\u683C\u5F0F\u65E0\u6548\u3002");
+    if (Date.now() < this.blockedUntil) throw new ScreenLockError("\u5BC6\u7801\u9A8C\u8BC1\u5931\u8D25\u6B21\u6570\u8FC7\u591A\uFF0C\u8BF7\u7B49\u5F85 30 \u79D2\u540E\u91CD\u8BD5\u3002");
+    const status = await this.status();
+    check();
+    if (!status.locked) return status;
+    if (!status.canUnlock) throw new ScreenLockError(status.message ?? "\u4E3B\u673A\u4E0D\u652F\u6301\u5C4F\u5E55\u89E3\u9501\u3002");
+    let valid;
+    try {
+      valid = await this.authenticate(this.stateDirectory, this.account.username, password);
+    } catch {
+      throw new ScreenLockError("\u65E0\u6CD5\u9A8C\u8BC1\u4E3B\u673A\u5BC6\u7801\uFF0C\u8BF7\u68C0\u67E5\u4E3B\u673A\u8BA4\u8BC1\u8F85\u52A9\u7A0B\u5E8F\u3002");
+    }
+    check();
+    if (!valid) {
+      if (++this.failures >= 3) {
+        this.blockedUntil = Date.now() + 3e4;
+        this.failures = 0;
+      }
+      throw new ScreenLockError("\u4E3B\u673A\u767B\u5F55\u5BC6\u7801\u9519\u8BEF\uFF0C\u8BF7\u91CD\u65B0\u8F93\u5165\u3002");
+    }
+    this.failures = 0;
+    if (this.system === "darwin") {
+      const helper = await this.macHelper();
+      check();
+      const bytes = Buffer.from(password, "utf8"), input = Buffer.alloc(bytes.length + 2);
+      input.writeUInt16BE(bytes.length);
+      bytes.copy(input, 2);
+      bytes.fill(0);
+      let result;
+      try {
+        result = this.parseStatus(await this.execute(helper, ["unlock"], input, signal));
+      } finally {
+        input.fill(0);
+      }
+      check();
+      if (result.locked) throw new ScreenLockError(nativeErrors.timeout);
+      return result;
+    }
+    const session = await this.linuxSession(signal);
+    check();
+    if (session.locked) await this.execute("loginctl", ["--no-ask-password", "unlock-session", session.id], void 0, signal);
+    for (let i = 0; i < 20; i++) {
+      check();
+      const current = await this.linuxSession(signal);
+      if (current.id !== session.id) throw new ScreenLockError("\u4E3B\u673A\u6D3B\u52A8\u4F1A\u8BDD\u5DF2\u53D8\u5316\uFF0C\u5DF2\u505C\u6B62\u89E3\u9501\u3002");
+      if (!current.locked) return { ...status, locked: false };
+      await delay(250, void 0, { signal }).catch(() => check());
+    }
+    throw new ScreenLockError("\u684C\u9762\u9501\u5C4F\u7A0B\u5E8F\u672A\u54CD\u5E94\u89E3\u9501\u8BF7\u6C42\uFF0C\u8BF7\u786E\u8BA4\u5B83\u652F\u6301 systemd-logind \u7684 Unlock \u4FE1\u53F7\u3002");
+  }
+};
+
 // src/journal.ts
 var Journal = class {
   constructor(directory) {
@@ -12286,8 +12534,8 @@ var Journal = class {
       return active.result;
     }
     const run4 = async () => {
-      const path = join4(this.directory, `${command.id}.json`);
-      const readOnly = isReadOperation(command.operation) || isAuthentication(command.operation);
+      const path = join6(this.directory, `${command.id}.json`);
+      const readOnly = command.operation.startsWith("desktop.") || isReadOperation(command.operation) || isAuthentication(command.operation);
       if (!readOnly) {
         const old = await readJson(path);
         if (old) {
@@ -12300,7 +12548,7 @@ var Journal = class {
       try {
         response = { type: "response", id: command.id, botId: command.botId, status: "completed", data: await action() };
       } catch (error) {
-        response = this.failure(command, isAuthentication(command.operation) ? "\u8BA4\u8BC1\u64CD\u4F5C\u5931\u8D25\uFF0C\u8BF7\u68C0\u67E5\u7F16\u7801\u5DE5\u5177\u7684\u767B\u5F55\u72B6\u6001\u540E\u91CD\u8BD5" : error instanceof Error ? error.message : "Operation failed");
+        response = this.failure(command, command.operation === "desktop.unlock" ? error instanceof ScreenLockError ? error.message : "\u5C4F\u5E55\u89E3\u9501\u5931\u8D25\uFF0C\u8BF7\u68C0\u67E5\u4E3B\u673A\u72B6\u6001\u4E0E\u6743\u9650\u540E\u91CD\u8BD5\u3002" : isAuthentication(command.operation) ? "\u8BA4\u8BC1\u64CD\u4F5C\u5931\u8D25\uFF0C\u8BF7\u68C0\u67E5\u7F16\u7801\u5DE5\u5177\u7684\u767B\u5F55\u72B6\u6001\u540E\u91CD\u8BD5" : error instanceof Error ? error.message : "Operation failed");
         if (!readOnly && error instanceof Error && ["TimeoutError", "AbortError", "UnknownResultError"].includes(error.name)) response.status = "unknown";
       }
       if (!readOnly) await atomicJson(path, { hash, response, finishedAt: (/* @__PURE__ */ new Date()).toISOString() });
@@ -12322,6 +12570,7 @@ var Journal = class {
     return result;
   }
   queueKey(c) {
+    if (c.operation.startsWith("desktop.")) return void 0;
     if (isReadOperation(c.operation) || isAuthentication(c.operation)) return void 0;
     const [group] = c.operation.split(".");
     if (c.operation === "sessions.abort") return JSON.stringify(["abort", c.projectId, c.sessionId]);
@@ -12406,8 +12655,8 @@ function pageHistory(input, payload) {
 
 // src/artifacts.ts
 import { createHash as createHash5 } from "node:crypto";
-import { join as join5 } from "node:path";
-import { readFile as readFile4, writeFile as writeFile2, mkdir as mkdir4, stat as stat5 } from "node:fs/promises";
+import { join as join7 } from "node:path";
+import { readFile as readFile4, writeFile as writeFile2, mkdir as mkdir6, stat as stat7 } from "node:fs/promises";
 var Artifacts = class {
   constructor(workspace, directory, emit) {
     this.workspace = workspace;
@@ -12423,7 +12672,7 @@ var Artifacts = class {
   }
   index(project) {
     this.workspace.project(project);
-    return join5(this.directory, project, "index.json");
+    return join7(this.directory, project, "index.json");
   }
   async list(project) {
     return Object.values(await readJson(this.index(project)) ?? {});
@@ -12461,9 +12710,9 @@ var Artifacts = class {
           changed = true;
         }
         if (previous?.hash !== hash || previous.deleted) {
-          const dir = join5(this.directory, project, "blobs");
-          await mkdir4(dir, { recursive: true, mode: 448 });
-          await writeFile2(join5(dir, hash), data, { mode: 384 });
+          const dir = join7(this.directory, project, "blobs");
+          await mkdir6(dir, { recursive: true, mode: 448 });
+          await writeFile2(join7(dir, hash), data, { mode: 384 });
           record2.revisions.push({ hash, timestamp: (/* @__PURE__ */ new Date()).toISOString() });
           changed = true;
         }
@@ -12479,7 +12728,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 stat7(await this.workspace.path(project, item.path));
       } catch (e) {
         if (e.code === "ENOENT") {
           item.revisions.push({ hash: "", timestamp: (/* @__PURE__ */ new Date()).toISOString(), deleted: true });
@@ -12499,7 +12748,7 @@ var Artifacts = class {
   }
   async read(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");
-    return readFile4(join5(this.directory, project, "blobs", hash), "utf8");
+    return readFile4(join7(this.directory, project, "blobs", hash), "utf8");
   }
   associate(project, path, sessionId) {
     return this.serial(project, () => this.associateUnlocked(project, path, sessionId));
@@ -12516,82 +12765,9 @@ var Artifacts = class {
 // src/secure-chat.ts
 import WebSocket from "ws";
 import { Duplex } from "node:stream";
-import { createPublicKey, randomUUID as randomUUID7, verify } from "node:crypto";
-import { userInfo as userInfo2 } from "node:os";
+import { createPublicKey, randomUUID as randomUUID8, verify } from "node:crypto";
+import { userInfo as userInfo3 } from "node:os";
 import { TLSSocket, createSecureContext } from "node:tls";
-
-// src/host-auth.ts
-import { spawn } from "node:child_process";
-import { chmod as chmod2, mkdir as mkdir5, rename as rename3, stat as stat6, unlink as unlink4 } from "node:fs/promises";
-import { userInfo, platform as platform2 } from "node:os";
-import { randomUUID as randomUUID6 } from "node:crypto";
-import { join as join6 } from "node:path";
-import { fileURLToPath as fileURLToPath2 } from "node:url";
-function helperPath(stateDirectory) {
-  return join6(stateDirectory, "octopus-host-auth");
-}
-async function ensureHostAuth(stateDirectory) {
-  await mkdir5(stateDirectory, { recursive: true, mode: 448 });
-  const target = helperPath(stateDirectory);
-  const system = platform2();
-  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);
-  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"];
-  if (mac) args[args.length - 1] = temporary;
-  const compiler = spawn(mac ? "clang" : "cc", args, { stdio: ["ignore", "ignore", "pipe"] });
-  let diagnostics = "";
-  compiler.stderr.on("data", (chunk) => {
-    diagnostics += String(chunk).slice(0, 4096);
-  });
-  const exit = await new Promise((resolve4, reject) => {
-    compiler.on("error", reject);
-    compiler.on("exit", (code) => resolve4(code ?? 1));
-  });
-  if (exit !== 0) {
-    await unlink4(temporary).catch(() => {
-    });
-    throw new Error(`Host authentication helper build failed: ${diagnostics.trim()}`);
-  }
-  try {
-    await chmod2(temporary, 448);
-    await rename3(temporary, target);
-    return target;
-  } finally {
-    await unlink4(temporary).catch(() => {
-    });
-  }
-}
-async function verifyHostPassword(stateDirectory, username, password) {
-  if (username !== userInfo().username || !password || Buffer.byteLength(password) > 1024) return false;
-  const path = await ensureHostAuth(stateDirectory);
-  const child = spawn(path, [], { stdio: ["pipe", "pipe", "ignore"] });
-  const bytes = Buffer.from(password, "utf8");
-  const header2 = Buffer.alloc(2);
-  header2.writeUInt16BE(bytes.length);
-  child.stdin.end(Buffer.concat([header2, bytes]));
-  bytes.fill(0);
-  let output = "";
-  child.stdout.on("data", (chunk) => {
-    output += String(chunk).slice(0, 16);
-  });
-  const timer = setTimeout(() => child.kill("SIGKILL"), 1e4);
-  try {
-    const code = await new Promise((resolve4, reject) => {
-      child.on("error", reject);
-      child.on("exit", (value) => resolve4(value ?? 1));
-    });
-    return code === 0 && output.trim() === "OK";
-  } finally {
-    clearTimeout(timer);
-  }
-}
-
-// src/secure-chat.ts
 var OPEN = 1;
 var DATA = 2;
 var CLOSE = 3;
@@ -12649,13 +12825,13 @@ var SecureChat = class {
   }
   outer;
   sessions = /* @__PURE__ */ new Map();
-  epoch = randomUUID7();
+  epoch = randomUUID8();
   sequence = 0;
   events = [];
   eventBytes = 0;
   stopping = false;
   context;
-  serviceAccount = userInfo2().username;
+  serviceAccount = userInfo3().username;
   timer;
   start() {
     this.connect();
@@ -12861,7 +13037,7 @@ var SecureChat = class {
 };
 
 // src/proxy-snapshot.ts
-import { randomUUID as randomUUID8 } from "node:crypto";
+import { randomUUID as randomUUID9 } from "node:crypto";
 import { execFile as execFile3 } from "node:child_process";
 import { promisify as promisify3 } from "node:util";
 var execute2 = promisify3(execFile3);
@@ -12915,7 +13091,7 @@ async function buildProxySnapshot(config, runtime, adapter, requestedProjectId)
   let modelCatalogStatus = capabilities.includes("configuration.models") ? "unavailable" : "unsupported";
   if (status.healthy === true && projectId && capabilities.includes("configuration.models")) {
     try {
-      const command = { type: "command", id: randomUUID8(), botId: config.botId, operation: "configuration.models", projectId, payload: {} };
+      const command = { type: "command", id: randomUUID9(), botId: config.botId, operation: "configuration.models", projectId, payload: {} };
       models.push(...publicModels(await adapter.dispatch(command)));
       modelCatalogStatus = models.length ? "available" : "unavailable";
     } catch {
@@ -12942,11 +13118,11 @@ async function buildProxySnapshot(config, runtime, adapter, requestedProjectId)
 }
 
 // src/media.ts
-import { createHash as createHash6, randomUUID as randomUUID9 } from "node:crypto";
+import { createHash as createHash6, randomUUID as randomUUID10 } from "node:crypto";
 import { constants as constants3 } from "node:fs";
 import { open as open4, unlink as unlink5, realpath as realpath3 } from "node:fs/promises";
 import { basename as basename3, isAbsolute as isAbsolute3, relative as relative3, resolve as resolve3, sep as sep2 } from "node:path";
-import { fileURLToPath as fileURLToPath3 } from "node:url";
+import { fileURLToPath as fileURLToPath4 } from "node:url";
 
 // src/screenshot-delivery.ts
 var instructions = "\n\n[Octopus screenshot delivery]\nFor requested UI tests/screenshots, run the real application with the available test tools. Save each requested key-step or failure screenshot under the authorized project (prefer test-results/screenshots/ with a unique filename). After saving, immediately report it as ![step and result](relative/project/path.png) in your progress or final response. Octopus Proxy will attach the actual file to Claw. Never claim a screenshot or test succeeded without producing it; explain environment/tool blockers. Do not substitute generated mockups for test screenshots.\n[/Octopus screenshot delivery]";
@@ -13063,7 +13239,7 @@ var RemoteMedia = class {
       } else {
         let path = value.path ?? value.localPath ?? value.artifactUri ?? source.path ?? source.localPath ?? url;
         if (typeof path !== "string") throw new Error("Image has no readable data or project path");
-        if (path.startsWith("file:")) path = fileURLToPath3(path);
+        if (path.startsWith("file:")) path = fileURLToPath4(path);
         if (/^[a-z][a-z0-9+.-]*:/i.test(path)) throw new Error("Only images inside the authorized project can be returned");
         if (isAbsolute3(path)) {
           const root = await this.workspace.root(project);
@@ -13159,7 +13335,7 @@ var RemoteMedia = class {
     if (bytes.length === 0 || bytes.length > this.imageLimit()) throw new Error("Image is empty or exceeds size limit");
     const extension = { "image/png": "png", "image/jpeg": "jpg", "image/gif": "gif", "image/webp": "webp", "application/pdf": "pdf" }[mime] ?? "bin";
     const directory = await this.workspace.attachmentDirectory(project, "media", sha256), path = directory + "/asset." + extension;
-    const temp = await this.workspace.path(project, directory + "/.octopus-media-" + randomUUID9(), true);
+    const temp = await this.workspace.path(project, directory + "/.octopus-media-" + randomUUID10(), true);
     const file = await open4(temp, constants3.O_WRONLY | constants3.O_CREAT | constants3.O_EXCL | constants3.O_NOFOLLOW, 384);
     try {
       await file.writeFile(bytes);
@@ -14577,7 +14753,7 @@ function applyEdits(text, edits) {
 
 // src/project-config.ts
 import { readFile as readFile5, writeFile as writeFile3, unlink as unlink6 } from "node:fs/promises";
-import { createHash as createHash7, randomUUID as randomUUID10 } from "node:crypto";
+import { createHash as createHash7, randomUUID as randomUUID11 } from "node:crypto";
 var ProjectConfig = class {
   constructor(workspace, request) {
     this.workspace = workspace;
@@ -14628,7 +14804,7 @@ var ProjectConfig = class {
     if (!this.validator(parse2(updated))) throw new Error("Merged OpenCode configuration is invalid: " + JSON.stringify(this.validator.errors));
     if (exists) await this.workspace.write(project, name, updated, createHash7("sha256").update(original).digest("hex"));
     else {
-      const temporary = await this.workspace.path(project, `.octopus-config-${randomUUID10()}.tmp`, true);
+      const temporary = await this.workspace.path(project, `.octopus-config-${randomUUID11()}.tmp`, true);
       try {
         await writeFile3(temporary, updated, { mode: 384, flag: "wx" });
         await this.workspace.publish(project, temporary, name);
@@ -15086,11 +15262,11 @@ function redact(value) {
 }
 
 // src/runtime.ts
-import { spawn as spawn2 } from "node:child_process";
+import { spawn as spawn3 } from "node:child_process";
 import { createHash as createHash8 } from "node:crypto";
-import { mkdir as mkdir6, open as open5, readFile as readFile6, rm, writeFile as writeFile4 } from "node:fs/promises";
+import { mkdir as mkdir7, open as open5, readFile as readFile6, rm as rm2, writeFile as writeFile4 } from "node:fs/promises";
 import { createServer } from "node:net";
-import { join as join7 } from "node:path";
+import { join as join8 } from "node:path";
 var Runtime = class {
   constructor(config) {
     this.config = config;
@@ -15106,7 +15282,7 @@ var Runtime = class {
     return this.endpoint;
   }
   get endpointStatePath() {
-    return join7(this.config.stateDirectory, "opencode-endpoint.json");
+    return join8(this.config.stateDirectory, "opencode-endpoint.json");
   }
   get passwordHash() {
     return createHash8("sha256").update(this.config.tool.password).digest("hex");
@@ -15168,13 +15344,13 @@ var Runtime = class {
         throw new Error(`OpenCode \u5730\u5740 ${url.origin} \u5DF2\u6709 HTTP \u670D\u52A1\uFF0C\u4F46\u5065\u5EB7\u68C0\u67E5\u5931\u8D25\uFF08HTTP ${response.status}\uFF09\uFF1B\u8BF7\u68C0\u67E5\u670D\u52A1\u5BC6\u7801\u6216\u7AEF\u53E3`);
       }
     }
-    await mkdir6(this.config.stateDirectory, { recursive: true, mode: 448 });
-    const logPath = join7(this.config.stateDirectory, "opencode-serve.log");
+    await mkdir7(this.config.stateDirectory, { recursive: true, mode: 448 });
+    const logPath = join8(this.config.stateDirectory, "opencode-serve.log");
     const log = await open5(logPath, "a", 384);
     const env = { ...process.env, OPENCODE_SERVER_PASSWORD: this.config.tool.password, OPENCODE_SERVER_USERNAME: "opencode" };
     let child;
     try {
-      child = spawn2(this.config.tool.command, ["serve", "--hostname", url.hostname === "[::1]" ? "::1" : url.hostname, "--port", url.port || "80"], {
+      child = spawn3(this.config.tool.command, ["serve", "--hostname", url.hostname === "[::1]" ? "::1" : url.hostname, "--port", url.port || "80"], {
         cwd: this.config.projects[0].directory,
         env,
         detached: true,
@@ -15212,7 +15388,7 @@ var Runtime = class {
       await new Promise((resolve4) => setTimeout(resolve4, 250));
     }
     if (child.exitCode === null && child.signalCode === null) child.kill("SIGTERM");
-    await rm(this.endpointStatePath, { force: true }).catch(() => {
+    await rm2(this.endpointStatePath, { force: true }).catch(() => {
     });
     this.endpoint = this.config.tool.baseUrl;
     throw new Error(`OpenCode \u542F\u52A8\u5931\u8D25\u6216\u5065\u5EB7\u68C0\u67E5\u8D85\u65F6\uFF1B\u8BF7\u68C0\u67E5 ${logPath}\u3001\u670D\u52A1\u5730\u5740\u548C\u5BC6\u7801`);
@@ -15261,24 +15437,24 @@ var Runtime = class {
 
 // src/tools/zcode-env.ts
 import { existsSync } from "node:fs";
-import { dirname as dirname4, join as join8 } from "node:path";
+import { dirname as dirname4, join as join9 } from "node:path";
 function zcodeEnvironment(command) {
   const env = { ...process.env };
   if (!env.ZCODE_BUILTIN_PROVIDER_CONFIG_FILE) {
-    const bundled = join8(dirname4(command), "..", "config", "provider", "zcode-builtin.json");
+    const bundled = join9(dirname4(command), "..", "config", "provider", "zcode-builtin.json");
     if (existsSync(bundled)) env.ZCODE_BUILTIN_PROVIDER_CONFIG_FILE = bundled;
   }
   return env;
 }
 
 // src/tools/stdio-runtime.ts
-import { spawn as spawn3, execFile as execFile4 } from "node:child_process";
+import { spawn as spawn4, execFile as execFile4 } from "node:child_process";
 import { promisify as promisify4 } from "node:util";
-import { mkdir as mkdir7, open as open6 } from "node:fs/promises";
-import { join as join9 } from "node:path";
+import { mkdir as mkdir8, open as open6 } from "node:fs/promises";
+import { join as join10 } from "node:path";
 
 // src/tools/line-rpc.ts
-import { randomUUID as randomUUID11 } from "node:crypto";
+import { randomUUID as randomUUID12 } from "node:crypto";
 import { crc32 } from "node:zlib";
 import { StringDecoder } from "node:string_decoder";
 function interrupted(message) {
@@ -15463,7 +15639,7 @@ var LineRpc = class {
   }
 };
 function wrapEnvelope(frame) {
-  return { wireVersion: 3, kind: "complete", deliveryKind: "desktop-continuous", logicalFrameId: randomUUID11(), logicalFrameOrdinal: 1, topic: "outbound", subscriptionId: "outbound", frame };
+  return { wireVersion: 3, kind: "complete", deliveryKind: "desktop-continuous", logicalFrameId: randomUUID12(), logicalFrameOrdinal: 1, topic: "outbound", subscriptionId: "outbound", frame };
 }
 
 // src/tools/stdio-runtime.ts
@@ -15639,12 +15815,12 @@ ${bytes.toString("utf8")}`);
     if (inFlight) return inFlight;
     if (this.children.has(projectId)) return;
     const spawnOnce = (async () => {
-      const logPath = join9(this.config.stateDirectory, `${this.kind}-${projectId}.log`);
-      await mkdir7(this.config.stateDirectory, { recursive: true, mode: 448 });
+      const logPath = join10(this.config.stateDirectory, `${this.kind}-${projectId}.log`);
+      await mkdir8(this.config.stateDirectory, { recursive: true, mode: 448 });
       const log = await open6(logPath, "a", 384);
       let child;
       try {
-        child = spawn3(this.config.tool.command, [...this.descriptor.serverArgs], { cwd: directory, env: this.kind === "zcode" ? zcodeEnvironment(this.config.tool.command) : { ...process.env }, stdio: ["pipe", "pipe", log.fd] });
+        child = spawn4(this.config.tool.command, [...this.descriptor.serverArgs], { cwd: directory, env: this.kind === "zcode" ? zcodeEnvironment(this.config.tool.command) : { ...process.env }, stdio: ["pipe", "pipe", log.fd] });
       } catch (error) {
         await log.close();
         throw error;
@@ -15693,14 +15869,14 @@ ${bytes.toString("utf8")}`);
       return;
     }
     this.attempts.set(projectId, attempts);
-    const delay = Math.min(3e4, 1e3 * 2 ** attempts);
+    const delay2 = Math.min(3e4, 1e3 * 2 ** attempts);
     this.timers.set(projectId, setTimeout(() => {
       this.timers.delete(projectId);
       if (!this.wanted || this.detached) return;
       const project = this.config.projects.find((entry) => entry.id === projectId);
       if (project) void this.track(projectId, project.directory).catch(() => {
       });
-    }, delay));
+    }, delay2));
   }
   kill(projectId) {
     clearTimeout(this.timers.get(projectId));
@@ -15719,7 +15895,7 @@ ${bytes.toString("utf8")}`);
 };
 
 // src/tools/codex.ts
-import { join as join10 } from "node:path";
+import { join as join11 } from "node:path";
 
 // src/adapter.ts
 var DAEMON_OPERATIONS = [
@@ -15755,14 +15931,16 @@ var DAEMON_OPERATIONS = [
   "terminal.attach",
   "desktop.list",
   "desktop.capture",
-  "desktop.read"
+  "desktop.read",
+  "desktop.lockStatus",
+  "desktop.unlock"
 ];
 function unsupportedOperation(kind, operation) {
   throw new Error(`Unsupported ${kind} operation: ${operation}`);
 }
 
 // src/tools/codex.ts
-import { randomUUID as randomUUID12 } from "node:crypto";
+import { randomUUID as randomUUID13 } from "node:crypto";
 var OPERATIONS = [
   ...DAEMON_OPERATIONS,
   ...AUTH_OPERATIONS,
@@ -15857,7 +16035,7 @@ var CodexAdapter = class {
   }
   onServerRequest(project, id, method, params, respond) {
     const detail = params ?? {};
-    const requestId = randomUUID12();
+    const requestId = randomUUID13();
     const threadId = String(detail.threadId ?? "");
     if (["item/permissions/requestApproval", "item/commandExecution/requestApproval", "item/fileChange/requestApproval"].includes(method)) {
       this.approvals.set(requestId, { project, method, requestId, threadId, detail, respond });
@@ -15872,21 +16050,21 @@ var CodexAdapter = class {
     respond({ decision: "decline" });
   }
   async index(project) {
-    const stored = await readJson(join10(this.runtime.config.stateDirectory, `codex-${project}.json`));
+    const stored = await readJson(join11(this.runtime.config.stateDirectory, `codex-${project}.json`));
     return { threadIds: stored?.threadIds ?? [] };
   }
   async remember(project, threadId) {
     const index = await this.index(project);
     if (!index.threadIds.includes(threadId)) {
       index.threadIds.push(threadId);
-      await atomicJson(join10(this.runtime.config.stateDirectory, `codex-${project}.json`), index);
+      await atomicJson(join11(this.runtime.config.stateDirectory, `codex-${project}.json`), index);
     }
   }
   async forget(project, threadId) {
     const index = await this.index(project);
     if (index.threadIds.includes(threadId)) {
       index.threadIds = index.threadIds.filter((entry) => entry !== threadId);
-      await atomicJson(join10(this.runtime.config.stateDirectory, `codex-${project}.json`), index);
+      await atomicJson(join11(this.runtime.config.stateDirectory, `codex-${project}.json`), index);
     }
   }
   async resume(project, threadId, rpc) {
@@ -16229,8 +16407,8 @@ var CodexAdapter = class {
 };
 
 // src/tools/zcode.ts
-import { spawn as spawn4 } from "node:child_process";
-import { randomUUID as randomUUID13 } from "node:crypto";
+import { spawn as spawn5 } from "node:child_process";
+import { randomUUID as randomUUID14 } from "node:crypto";
 import { realpath as realpath5 } from "node:fs/promises";
 var OPERATIONS2 = [
   ...DAEMON_OPERATIONS,
@@ -16285,7 +16463,7 @@ var ZcodeAdapter = class {
   }
   onServerRequest(project, id, method, params, respond, respondError) {
     const detail = params ?? {};
-    const requestId = randomUUID13();
+    const requestId = randomUUID14();
     const sessionId = String(detail.sessionId ?? "");
     if (method === "session/requestRuntimePreferences") {
       respond({ nativeSearchEnhancementsEnabled: false });
@@ -16422,7 +16600,7 @@ var ZcodeAdapter = class {
       const flow = this.auth.create(project, () => {
         child?.kill("SIGTERM");
       });
-      child = spawn4(this.runtime.config.tool.command, ["login", "--no-browser", "--json"], { cwd: await this.workspace.root(project), env: zcodeEnvironment(this.runtime.config.tool.command), stdio: ["ignore", "pipe", "pipe"] });
+      child = spawn5(this.runtime.config.tool.command, ["login", "--no-browser", "--json"], { cwd: await this.workspace.root(project), env: zcodeEnvironment(this.runtime.config.tool.command), stdio: ["ignore", "pipe", "pipe"] });
       let output = "", diagnostic = "";
       child.stdout?.on("data", (data) => {
         output = (output + data.toString()).slice(-65536);
@@ -16560,8 +16738,8 @@ var ZcodeAdapter = class {
 };
 
 // src/tools/pi.ts
-import { randomUUID as randomUUID14 } from "node:crypto";
-import { readFile as readFile7, readdir as readdir3, rm as rm2 } from "node:fs/promises";
+import { randomUUID as randomUUID15 } from "node:crypto";
+import { readFile as readFile7, readdir as readdir3, rm as rm3 } from "node:fs/promises";
 import { dirname as dirname5 } from "node:path";
 var OPERATIONS3 = [
   ...DAEMON_OPERATIONS,
@@ -16655,7 +16833,7 @@ var PiAdapter = class {
   }
   onQuestion(project, sessionId, detail) {
     if (!["select", "confirm", "input", "editor"].includes(String(detail.method))) return;
-    const id = randomUUID14();
+    const id = randomUUID15();
     void this.rpc(project, sessionId).then((rpc) => {
       if (rpc.exited) return;
       const question = { id, project, sessionId, detail, rpc };
@@ -16761,7 +16939,7 @@ var PiAdapter = class {
       return sessions.sort((a, b) => b.time.updated - a.time.updated);
     }
     if (op === "sessions.create") {
-      const session2 = { id: randomUUID14(), title: typeof p.title === "string" && p.title.trim() ? p.title : "\u65B0\u4EFB\u52A1", directory: await this.workspace.root(project), time: { created: Date.now(), updated: Date.now() } };
+      const session2 = { id: randomUUID15(), title: typeof p.title === "string" && p.title.trim() ? p.title : "\u65B0\u4EFB\u52A1", directory: await this.workspace.root(project), time: { created: Date.now(), updated: Date.now() } };
       try {
         const rpc2 = await this.rpc(project, session2.id);
         await rpc2.request("set_session_name", { name: session2.title });
@@ -16808,8 +16986,8 @@ var PiAdapter = class {
       this.deleting.add(this.key(project, id));
       try {
         await this.runtime.closeSession(project, id);
-        await rm2(this.runtime.sessionFile(project, id), { force: true });
-        await rm2(this.metadataPath(project, id));
+        await rm3(this.runtime.sessionFile(project, id), { force: true });
+        await rm3(this.metadataPath(project, id));
         this.clearQuestions(project, id);
       } finally {
         this.deleting.delete(this.key(project, id));
@@ -16859,9 +17037,9 @@ var PiAdapter = class {
 };
 
 // src/tools/pi-runtime.ts
-import { execFile as execFile5, spawn as spawn5 } from "node:child_process";
-import { mkdir as mkdir8, open as open7 } from "node:fs/promises";
-import { join as join11 } from "node:path";
+import { execFile as execFile5, spawn as spawn6 } from "node:child_process";
+import { mkdir as mkdir9, open as open7 } from "node:fs/promises";
+import { join as join12 } from "node:path";
 import { promisify as promisify5 } from "node:util";
 var run3 = promisify5(execFile5);
 var PiRuntime = class {
@@ -16947,7 +17125,7 @@ ${bytes.toString("utf8")}`);
   sessionFile(projectId, sessionId) {
     this.project(projectId);
     if (!describeTool("pi").sessionPattern.test(sessionId)) throw new Error("Invalid session id");
-    return join11(this.config.stateDirectory, "pi-sessions", projectId, `${sessionId}.jsonl`);
+    return join12(this.config.stateDirectory, "pi-sessions", projectId, `${sessionId}.jsonl`);
   }
   project(id) {
     const project = this.config.projects.find((entry) => entry.id === id);
@@ -16978,15 +17156,15 @@ ${bytes.toString("utf8")}`);
   async launch(key, projectId, sessionId, handlers, generation) {
     await this.kill(key);
     const directory = this.project(projectId).directory;
-    await mkdir8(join11(this.config.stateDirectory, "pi-sessions", projectId), { recursive: true, mode: 448 });
-    const logPath = join11(this.config.stateDirectory, `pi-${key}.log`);
+    await mkdir9(join12(this.config.stateDirectory, "pi-sessions", projectId), { recursive: true, mode: 448 });
+    const logPath = join12(this.config.stateDirectory, `pi-${key}.log`);
     const log = await open7(logPath, "a", 384);
     if (generation !== this.generation) {
       await log.close();
       throw new Error("Pi runtime stopped during startup");
     }
     const args = [...describeTool("pi").serverArgs, ...sessionId ? ["--session", this.sessionFile(projectId, sessionId)] : ["--no-session"]];
-    const child = spawn5(this.config.tool.command, args, { cwd: directory, env: { ...process.env }, stdio: ["pipe", "pipe", log.fd] });
+    const child = spawn6(this.config.tool.command, args, { cwd: directory, env: { ...process.env }, stdio: ["pipe", "pipe", log.fd] });
     child.once("close", () => {
       void log.close();
     });
@@ -17041,7 +17219,7 @@ function createAdapter(runtime, workspace, uploads, emit) {
 }
 
 // src/project-registry.ts
-import { realpath as realpath6, readFile as readFile8, stat as stat7 } from "node:fs/promises";
+import { realpath as realpath6, readFile as readFile8, stat as stat8 } from "node:fs/promises";
 import { isAbsolute as isAbsolute4 } from "node:path";
 var ProjectMutationSchema = ProjectSchema.extend({
   name: ProjectSchema.shape.name.trim().max(120),
@@ -17101,7 +17279,7 @@ var ProjectRegistry = class {
     const parsed = ProjectMutationSchema.parse(payload);
     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}`);
@@ -17121,7 +17299,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) {
@@ -17168,10 +17346,10 @@ var ProjectRegistry = class {
 };
 
 // src/terminal.ts
-import { randomUUID as randomUUID15 } from "node:crypto";
+import { randomUUID as randomUUID16 } from "node:crypto";
 import { access } from "node:fs/promises";
 import { constants as constants4 } from "node:fs";
-import { platform as platform3, userInfo as userInfo3 } from "node:os";
+import { platform as platform3, userInfo as userInfo4 } from "node:os";
 import * as pty from "node-pty";
 var TerminalManager = class {
   constructor(workspace, emit) {
@@ -17196,13 +17374,13 @@ var TerminalManager = class {
       const cwd = await this.workspace.path(project, typeof p.cwd === "string" ? p.cwd : ".");
       const shell = process.env.SHELL || (platform3() === "darwin" ? "/bin/zsh" : "/bin/sh");
       await access(shell, constants4.X_OK);
-      const id = randomUUID15();
+      const id = randomUUID16();
       const terminalProcess = pty.spawn(shell, [], {
         name: "xterm-256color",
         cols: 80,
         rows: 24,
         cwd,
-        env: { PATH: process.env.PATH || "/usr/bin:/bin", HOME: userInfo3().homedir, TERM: "xterm-256color", USER: userInfo3().username }
+        env: { PATH: process.env.PATH || "/usr/bin:/bin", HOME: userInfo4().homedir, TERM: "xterm-256color", USER: userInfo4().username }
       });
       const terminal2 = { id, project, owner, process: terminalProcess, history: "" };
       this.terminals.set(id, terminal2);
@@ -17255,10 +17433,10 @@ var TerminalManager = class {
 // src/desktop.ts
 import { execFile as execFile6 } from "node:child_process";
 import { promisify as promisify6 } from "node:util";
-import { createHash as createHash9, randomUUID as randomUUID16 } from "node:crypto";
-import { chmod as chmod3, mkdir as mkdir9, mkdtemp, readFile as readFile9, rename as rename4, rm as rm3, stat as stat8 } from "node:fs/promises";
-import { join as join12 } from "node:path";
-import { fileURLToPath as fileURLToPath4 } from "node:url";
+import { createHash as createHash9, randomUUID as randomUUID17 } from "node:crypto";
+import { chmod as chmod4, mkdir as mkdir10, mkdtemp, readFile as readFile9, rename as rename5, rm as rm4, stat as stat9 } from "node:fs/promises";
+import { join as join13 } from "node:path";
+import { fileURLToPath as fileURLToPath5 } from "node:url";
 var DESKTOP_IMAGE_LIMIT = 20 * 1024 * 1024;
 var DESKTOP_CHUNK_LIMIT = 512 * 1024;
 var PNG_SIGNATURE = Buffer.from("89504e470d0a1a0a", "hex");
@@ -17323,19 +17501,19 @@ var PlatformDesktop = class {
   macHelper() {
     if (this.helper) return this.helper;
     this.helper = (async () => {
-      await mkdir9(this.stateDirectory, { recursive: true, mode: 448 });
-      const target = join12(this.stateDirectory, "octopus-desktop-capture");
-      const source = fileURLToPath4(new URL("../native/desktop-macos.m", import.meta.url));
-      const sourceInfo = await stat8(source), existing = await stat8(target).catch(() => null);
+      await mkdir10(this.stateDirectory, { recursive: true, mode: 448 });
+      const target = join13(this.stateDirectory, "octopus-desktop-capture");
+      const source = fileURLToPath5(new URL("../native/desktop-macos.m", import.meta.url));
+      const sourceInfo = await stat9(source), existing = await stat9(target).catch(() => null);
       if (existing?.isFile() && existing.mtimeMs >= sourceInfo.mtimeMs && (existing.mode & 63) === 0) return target;
-      const temporary = `${target}.${randomUUID16()}`;
+      const temporary = `${target}.${randomUUID17()}`;
       try {
         await this.execute("/usr/bin/clang", ["-O2", "-fobjc-arc", "-mmacosx-version-min=12.3", "-framework", "Foundation", "-framework", "AppKit", "-framework", "ScreenCaptureKit", "-framework", "CoreMedia", "-framework", "CoreVideo", "-framework", "VideoToolbox", "-framework", "ImageIO", source, "-o", temporary]);
-        await chmod3(temporary, 448);
-        await rename4(temporary, target);
+        await chmod4(temporary, 448);
+        await rename5(temporary, target);
         return target;
       } finally {
-        await rm3(temporary, { force: true });
+        await rm4(temporary, { force: true });
       }
     })();
     this.helper.catch(() => {
@@ -17419,9 +17597,9 @@ var PlatformDesktop = class {
   async capture(displayId) {
     const display = (await this.list()).find((item) => item.id === displayId);
     if (!display) throw new Error("\u6240\u9009\u663E\u793A\u5668\u5DF2\u65AD\u5F00\uFF0C\u8BF7\u5237\u65B0\u663E\u793A\u5668\u5217\u8868\u540E\u91CD\u8BD5\u3002");
-    await mkdir9(this.stateDirectory, { recursive: true, mode: 448 });
-    const directory = await mkdtemp(join12(this.stateDirectory, "desktop-capture-"));
-    const output = join12(directory, "screen.png");
+    await mkdir10(this.stateDirectory, { recursive: true, mode: 448 });
+    const directory = await mkdtemp(join13(this.stateDirectory, "desktop-capture-"));
+    const output = join13(directory, "screen.png");
     try {
       if (this.system === "darwin") {
         await this.execute(await this.macHelper(), ["capture", display.id, output]);
@@ -17439,24 +17617,39 @@ var PlatformDesktop = class {
           await this.execute("import", args);
         }
       }
-      const info = await stat8(output);
+      const info = await stat9(output);
       if (!info.isFile() || !info.size || info.size > DESKTOP_IMAGE_LIMIT) throw new Error("\u684C\u9762\u622A\u56FE\u4E3A\u7A7A\u6216\u8D85\u8FC7 20 MiB \u4E0A\u9650\u3002");
       return { display, bytes: await readFile9(output) };
     } finally {
-      await rm3(directory, { recursive: true, force: true });
+      await rm4(directory, { recursive: true, force: true });
     }
   }
 };
 var DesktopManager = class {
-  constructor(backend) {
+  constructor(backend, screenLock) {
     this.backend = backend;
+    this.screenLock = screenLock;
   }
   captures = /* @__PURE__ */ new Map();
   pending = /* @__PURE__ */ new Map();
+  unlocking;
   closed = false;
   async dispatch(command, owner) {
     if (this.closed) throw new Error("\u684C\u9762\u622A\u5C4F\u670D\u52A1\u5DF2\u505C\u6B62\u3002");
     const p = command.payload;
+    if (command.operation === "desktop.lockStatus" || command.operation === "desktop.unlock") {
+      if (!this.screenLock) throw new ScreenLockError("\u6B64 Proxy \u4E0D\u652F\u6301\u5C4F\u5E55\u89E3\u9501\uFF0C\u8BF7\u5347\u7EA7 Proxy\u3002");
+      if (command.operation === "desktop.lockStatus") return this.screenLock.status();
+      if (typeof p.password !== "string" || !p.password || Buffer.byteLength(p.password) > 1024 || /[\x00-\x1f\x7f]/.test(p.password)) throw new ScreenLockError("\u8BF7\u8F93\u5165\u6709\u6548\u7684\u4E3B\u673A\u767B\u5F55\u5BC6\u7801\uFF08\u6700\u591A 1024 \u5B57\u8282\uFF0C\u4E0D\u80FD\u5305\u542B\u63A7\u5236\u5B57\u7B26\uFF09\u3002");
+      if (this.unlocking) throw new ScreenLockError("\u6B63\u5728\u89E3\u9501\u4E3B\u673A\u5C4F\u5E55\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5\u3002");
+      const pending = { owner, abort: new AbortController() };
+      this.unlocking = pending;
+      try {
+        return await this.screenLock.unlock(p.password, pending.abort.signal);
+      } finally {
+        if (this.unlocking === pending) this.unlocking = void 0;
+      }
+    }
     if (command.operation === "desktop.list") return this.backend.list();
     if (command.operation === "desktop.capture") {
       if (typeof p.displayId !== "string" || !p.displayId) throw new Error("\u8BF7\u9009\u62E9\u663E\u793A\u5668\u3002");
@@ -17470,7 +17663,7 @@ var DesktopManager = class {
         if (bytes.length < 24 || !bytes.subarray(0, 8).equals(PNG_SIGNATURE) || bytes.toString("ascii", 12, 16) !== "IHDR") throw new Error("\u622A\u5C4F\u672A\u8FD4\u56DE\u6709\u6548\u7684 PNG \u56FE\u7247\u3002");
         const width = bytes.readUInt32BE(16), height = bytes.readUInt32BE(20);
         if (!width || !height) throw new Error("\u684C\u9762\u622A\u56FE\u5C3A\u5BF8\u65E0\u6548\u3002");
-        const info = { id: randomUUID16(), display: publicDisplay(display), capturedAt: (/* @__PURE__ */ new Date()).toISOString(), mime: "image/png", width, height, size: bytes.length, sha256: createHash9("sha256").update(bytes).digest("hex") };
+        const info = { id: randomUUID17(), display: publicDisplay(display), capturedAt: (/* @__PURE__ */ new Date()).toISOString(), mime: "image/png", width, height, size: bytes.length, sha256: createHash9("sha256").update(bytes).digest("hex") };
         this.clearCapture(owner);
         const timer = setTimeout(() => this.clearCapture(owner), 6e4);
         timer.unref();
@@ -17500,9 +17693,11 @@ var DesktopManager = class {
   closeOwned(owner) {
     this.pending.delete(owner);
     this.clearCapture(owner);
+    if (this.unlocking?.owner === owner) this.unlocking.abort.abort();
   }
   close() {
     this.closed = true;
+    this.unlocking?.abort.abort();
     this.pending.clear();
     for (const owner of this.captures.keys()) this.clearCapture(owner);
   }
@@ -17511,15 +17706,15 @@ var DesktopManager = class {
 // src/daemon.ts
 async function runDaemon(configPath, authenticate = verifyHostPassword) {
   const config = await loadConfig(configPath);
-  await mkdir10(config.stateDirectory, { recursive: true, mode: 448 });
-  const workspace = new Workspace(config.projects), runtime = createRuntime(config), uploads = new Uploads(workspace, join13(config.stateDirectory, "uploads")), journal = new Journal(join13(config.stateDirectory, "journal"));
+  await mkdir11(config.stateDirectory, { recursive: true, mode: 448 });
+  const workspace = new Workspace(config.projects), runtime = createRuntime(config), uploads = new Uploads(workspace, join14(config.stateDirectory, "uploads")), journal = new Journal(join14(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 desktop = new DesktopManager(new PlatformDesktop(config.stateDirectory));
-  const adapter = createAdapter(runtime, workspace, uploads, emit), artifacts = new Artifacts(workspace, join13(config.stateDirectory, "artifacts"), emit);
+  const desktop = new DesktopManager(new PlatformDesktop(config.stateDirectory), new PlatformScreenLock(config.stateDirectory));
+  const adapter = createAdapter(runtime, workspace, uploads, emit), artifacts = new Artifacts(workspace, join14(config.stateDirectory, "artifacts"), emit);
   const projectRegistry = new ProjectRegistry(configPath, config, runtime, adapter);
   async function dispatch(c, secureSessionId) {
     if (c.operation.startsWith("desktop.")) return desktop.dispatch(c, secureSessionId);

package/dist/cli.js

@@ -27,7 +27,7 @@ import {
   runDaemon,
   supportedPlatform,
   systemdUnitPath
-} from "./chunk-5OJQ46AF.js";
+} from "./chunk-6DTK4JVV.js";
 
 // src/cli.ts
 import { spawn } from "node:child_process";

package/dist/main.js

@@ -2,7 +2,7 @@
 import {
   ConfigError,
   runDaemon
-} from "./chunk-5OJQ46AF.js";
+} from "./chunk-6DTK4JVV.js";
 
 // src/main.ts
 runDaemon(process.env.OCTOPUS_PROXY_CONFIG ?? "proxy.json").catch((error) => {

package/native/screen-unlock-macos.m

@@ -0,0 +1,127 @@
+#import <AppKit/AppKit.h>
+#import <ApplicationServices/ApplicationServices.h>
+#include <unistd.h>
+#include <string.h>
+
+static void wipe(void *buffer, size_t length) {
+  volatile unsigned char *bytes = buffer;
+  while (length--) *bytes++ = 0;
+}
+
+static int fail(const char *code) { fprintf(stderr, "%s\n", code); return 1; }
+
+// This WindowServer property is not a documented public lock-state API. Fail
+// closed when the session is unavailable or is not this user's console desktop.
+static BOOL lockState(BOOL *locked) {
+  NSDictionary *session = CFBridgingRelease(CGSessionCopyCurrentDictionary());
+  if (!session || ![session[(__bridge NSString *)kCGSessionOnConsoleKey] boolValue] ||
+      ![session[(__bridge NSString *)kCGSessionLoginDoneKey] boolValue] ||
+      ![session[(__bridge NSString *)kCGSessionUserIDKey] isKindOfClass:NSNumber.class] ||
+      [session[(__bridge NSString *)kCGSessionUserIDKey] unsignedIntValue] != getuid()) return NO;
+  id value = session[@"CGSSessionScreenIsLocked"];
+  if (value && ![value isKindOfClass:NSNumber.class]) return NO;
+  *locked = [value boolValue];
+  return YES;
+}
+
+static void printStatus(BOOL locked) {
+  printf("{\"locked\":%s,\"canUnlock\":%s}", locked ? "true" : "false",
+         AXIsProcessTrusted() && CGPreflightPostEventAccess() ? "true" : "false");
+}
+
+static AXUIElementRef passwordFocus(void) {
+  AXUIElementRef system = AXUIElementCreateSystemWide();
+  AXUIElementSetMessagingTimeout(system, 0.5);
+  CFTypeRef focused = NULL;
+  AXError result = AXUIElementCopyAttributeValue(system, kAXFocusedUIElementAttribute, &focused);
+  CFRelease(system);
+  if (result != kAXErrorSuccess || !focused || CFGetTypeID(focused) != AXUIElementGetTypeID()) {
+    if (focused) CFRelease(focused);
+    return NULL;
+  }
+  pid_t pid = 0;
+  AXUIElementRef field = (AXUIElementRef)focused;
+  AXUIElementSetMessagingTimeout(field, 0.5);
+  NSRunningApplication *app = nil;
+  if (AXUIElementGetPid(field, &pid) == kAXErrorSuccess) app = [NSRunningApplication runningApplicationWithProcessIdentifier:pid];
+  CFTypeRef subrole = NULL;
+  AXUIElementCopyAttributeValue(field, kAXSubroleAttribute, &subrole);
+  BOOL secure = subrole && CFEqual(subrole, kAXSecureTextFieldSubrole);
+  if (subrole) CFRelease(subrole);
+  if (!secure || ![app.bundleIdentifier isEqualToString:@"com.apple.loginwindow"] ||
+      ![app.executableURL.path isEqualToString:@"/System/Library/CoreServices/loginwindow.app/Contents/MacOS/loginwindow"]) {
+    CFRelease(field); return NULL;
+  }
+  return field;
+}
+
+static BOOL stillFocused(AXUIElementRef field) {
+  BOOL locked = NO;
+  if (!lockState(&locked) || !locked) return NO;
+  AXUIElementRef current = passwordFocus();
+  BOOL same = current && CFEqual(current, field);
+  if (current) CFRelease(current);
+  return same;
+}
+
+static BOOL key(CGKeyCode code, CGEventFlags flags, const UniChar *text, size_t length) {
+  CGEventRef down = CGEventCreateKeyboardEvent(NULL, code, true);
+  CGEventRef up = CGEventCreateKeyboardEvent(NULL, code, false);
+  if (!down || !up) { if (down) CFRelease(down); if (up) CFRelease(up); return NO; }
+  CGEventSetFlags(down, flags); CGEventSetFlags(up, flags);
+  if (text) { CGEventKeyboardSetUnicodeString(down, length, text); CGEventKeyboardSetUnicodeString(up, length, text); }
+  CGEventPost(kCGHIDEventTap, down); CGEventPost(kCGHIDEventTap, up);
+  CFRelease(down); CFRelease(up);
+  usleep(20000);
+  return YES;
+}
+
+int main(int argc, const char *argv[]) {
+  @autoreleasepool {
+    if (getuid() == 0 || argc != 2) return fail("session");
+    BOOL locked = NO;
+    if (!lockState(&locked)) return fail("session");
+    if (strcmp(argv[1], "status") == 0) { printStatus(locked); return 0; }
+    if (strcmp(argv[1], "unlock") != 0) return fail("session");
+    if (!locked) { printStatus(NO); return 0; }
+    if (!AXIsProcessTrusted() || !CGPreflightPostEventAccess()) return fail("permission");
+    unsigned char header[2], bytes[1025] = {0};
+    if (fread(header, 1, 2, stdin) != 2) return fail("password");
+    size_t count = ((size_t)header[0] << 8) | header[1];
+    if (!count || count > 1024 || fread(bytes, 1, count, stdin) != count) { wipe(bytes, sizeof(bytes)); return fail("password"); }
+    NSString *password = [[NSString alloc] initWithBytes:bytes length:count encoding:NSUTF8StringEncoding];
+    wipe(bytes, sizeof(bytes));
+    if (!password || [password rangeOfCharacterFromSet:NSCharacterSet.controlCharacterSet].location != NSNotFound) return fail("password");
+    // A non-text key wakes the password prompt. Never type a secret into an
+    // arbitrary app, username field, clipboard, or a blind screen coordinate.
+    if (!lockState(&locked) || !locked) return fail("changed");
+    if (!key(56, 0, NULL, 0)) return fail("focus");
+    AXUIElementRef field = NULL;
+    for (int i = 0; i < 20 && !field; i++) { usleep(100000); field = passwordFocus(); }
+    if (!field) return fail("focus");
+    if (!stillFocused(field) || !key(0, kCGEventFlagMaskCommand, NULL, 0) ||
+        !stillFocused(field) || !key(51, 0, NULL, 0)) { CFRelease(field); return fail("changed"); }
+    UniChar characters[1024] = {0};
+    NSUInteger length = password.length;
+    if (length > 1024) { CFRelease(field); return fail("password"); }
+    [password getCharacters:characters range:NSMakeRange(0, length)];
+    password = nil;
+    BOOL sent = YES;
+    // One Unicode scalar per event avoids event-string truncation. Check the
+    // secure loginwindow focus and console lock immediately before each event.
+    for (NSUInteger i = 0; i < length;) {
+      NSUInteger units = CFStringIsSurrogateHighCharacter(characters[i]) && i + 1 < length && CFStringIsSurrogateLowCharacter(characters[i + 1]) ? 2 : 1;
+      if (!stillFocused(field) || !key(0, 0, &characters[i], units)) { sent = NO; break; }
+      i += units;
+    }
+    wipe(characters, sizeof(characters));
+    if (!sent || !stillFocused(field) || !key(36, 0, NULL, 0)) { CFRelease(field); return fail("changed"); }
+    CFRelease(field);
+    for (int i = 0; i < 50; i++) {
+      usleep(100000);
+      if (!lockState(&locked)) return fail("session");
+      if (!locked) { printStatus(NO); return 0; }
+    }
+    return fail("timeout");
+  }
+}

package/package.json

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