fix(exec-approvals): allow darwin state-dir aliases

AntiPhisher · AntiPhisher · commit ed21f35d05c2 · 2026-04-10T16:11:47.000+08:00
diff --git a/src/infra/exec-approvals-store.test.ts b/src/infra/exec-approvals-store.test.ts
@@ -260,6 +260,42 @@ describe("exec approvals store helpers", () => {
     expect(fs.existsSync(path.join(realStateRoot, "state"))).toBe(false);
   });
 
+  it("allows darwin system alias prefixes for OPENCLAW_STATE_DIR without masking user symlinks", () => {
+    createHomeDir();
+    const stateDir = createStateDir();
+    const originalPlatform = process.platform;
+    const realpathSync = fs.realpathSync.bind(fs);
+    const lstatSync = fs.lstatSync.bind(fs);
+    const lstatSpy = vi.spyOn(fs, "lstatSync").mockImplementation((targetPath: fs.PathLike) => {
+      const resolved = path.resolve(String(targetPath));
+      if (resolved === "/tmp") {
+        return {
+          isSymbolicLink: () => true,
+        } as unknown as fs.Stats;
+      }
+      return lstatSync(targetPath);
+    });
+    const realpathSpy = vi.spyOn(fs, "realpathSync").mockImplementation((targetPath: fs.PathLike) => {
+      const resolved = path.resolve(String(targetPath));
+      if (resolved === path.resolve(stateDir)) {
+        return `/private${resolved}`;
+      }
+      return realpathSync(targetPath);
+    });
+
+    Object.defineProperty(process, "platform", { value: "darwin" });
+    try {
+      expect(() =>
+        saveExecApprovals({ version: 1, defaults: { security: "full" }, agents: {} }),
+      ).not.toThrow();
+      expect(fs.existsSync(path.join(stateDir, "exec-approvals.json"))).toBe(true);
+    } finally {
+      realpathSpy.mockRestore();
+      lstatSpy.mockRestore();
+      Object.defineProperty(process, "platform", { value: originalPlatform });
+    }
+  });
+
   it("adds trimmed allowlist entries once and persists generated ids", () => {
     const dir = createHomeDir();
     vi.spyOn(Date, "now").mockReturnValue(123_456);
diff --git a/src/infra/exec-approvals.ts b/src/infra/exec-approvals.ts
@@ -239,23 +239,47 @@ function ensureDir(filePath: string) {
 
 function assertNoSymlinkPathComponents(targetPath: string): void {
   const resolvedTarget = path.resolve(targetPath);
-  const parsedTarget = path.parse(resolvedTarget);
-  const relative = path.relative(parsedTarget.root, resolvedTarget);
-  const segments = relative && relative !== "." ? relative.split(path.sep).filter(Boolean) : [];
-  let current = parsedTarget.root;
-  for (const segment of segments) {
-    current = path.join(current, segment);
+  const existingAncestor = findNearestExistingAncestor(resolvedTarget);
+  const relative = path.relative(existingAncestor, resolvedTarget);
+  const realAncestor = fs.realpathSync(existingAncestor);
+  const realTarget = path.resolve(realAncestor, relative);
+  if (
+    normalizeSymlinkComparisonPath(resolvedTarget) !== normalizeSymlinkComparisonPath(realTarget)
+  ) {
+    throw new Error(`Refusing to traverse symlink in exec approvals path: ${existingAncestor}`);
+  }
+}
+
+function findNearestExistingAncestor(targetPath: string): string {
+  let current = targetPath;
+  while (true) {
     try {
-      const stat = fs.lstatSync(current);
-      if (stat.isSymbolicLink()) {
-        throw new Error(`Refusing to traverse symlink in exec approvals path: ${current}`);
-      }
+      fs.lstatSync(current);
+      return current;
     } catch (err) {
       if ((err as NodeJS.ErrnoException).code !== "ENOENT") {
         throw err;
       }
     }
+    const parent = path.dirname(current);
+    if (parent === current) {
+      return current;
+    }
+    current = parent;
+  }
+}
+
+function normalizeSymlinkComparisonPath(targetPath: string): string {
+  const resolvedTarget = path.resolve(targetPath);
+  if (process.platform !== "darwin") {
+    return resolvedTarget;
+  }
+  for (const prefix of ["/private/tmp", "/private/var", "/private/etc"]) {
+    if (resolvedTarget === prefix || resolvedTarget.startsWith(`${prefix}${path.sep}`)) {
+      return resolvedTarget.slice("/private".length);
+    }
   }
+  return resolvedTarget;
 }
 
 function assertSafeExecApprovalsDestination(filePath: string): void {
