fix(snapshot): stabilize pending pairing publication

src/lib/actions/sandbox/auto-pair-approval-receipt.test.ts

@@ -0,0 +1,167 @@
+// SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import { type SpawnSyncOptionsWithStringEncoding, spawnSync } from "node:child_process";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { describe, expect, it, vi } from "vitest";
+
+import {
+  buildAutoPairApprovalScript,
+  classifyAutoPairApprovalExecReceipt,
+  parseAutoPairApprovalReceipt,
+  readAutoPairApprovalPolicyModule,
+  runSandboxAutoPairApprovalPass,
+} from "./auto-pair-approval";
+
+describe("auto-pair approval receipts (#4616)", () => {
+  const pythonUnavailable =
+    spawnSync("sh", ["-c", "command -v python3"], { stdio: "ignore" }).status !== 0;
+
+  it.skipIf(pythonUnavailable)("omits raw output from devices-list failure classifications", () => {
+    const policy = readAutoPairApprovalPolicyModule();
+    expect(policy).toBeTruthy();
+    const script = buildAutoPairApprovalScript(
+      Buffer.from(policy as string, "utf-8").toString("base64"),
+      {
+        emitReceipt: true,
+        budget: { listTimeoutS: 0.5 },
+      },
+    );
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "nemoclaw-auto-pair-list-receipt-"));
+    try {
+      fs.writeFileSync(
+        path.join(tmpDir, "openclaw"),
+        `#!${process.execPath}
+const args = process.argv.slice(2);
+if (args[0] !== "devices" || args[1] !== "list") process.exit(2);
+const sleepMs = Number(process.env.NEMOCLAW_LIST_SLEEP_MS || "0");
+if (sleepMs > 0) {
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, sleepMs);
+}
+process.stdout.write(process.env.NEMOCLAW_LIST_STDOUT || "");
+process.stderr.write(process.env.NEMOCLAW_LIST_STDERR || "");
+process.exit(Number(process.env.NEMOCLAW_LIST_EXIT_CODE || "0"));
+`,
+        { mode: 0o755 },
+      );
+      for (const [environment, receipt] of [
+        [{ NEMOCLAW_LIST_SLEEP_MS: "800" }, "list-timeout"],
+        [
+          { NEMOCLAW_LIST_EXIT_CODE: "1", NEMOCLAW_LIST_STDERR: "raw failure" },
+          "list-command-failed",
+        ],
+        [
+          {
+            NEMOCLAW_LIST_EXIT_CODE: "1",
+            NEMOCLAW_LIST_STDERR: "scope upgrade pending approval raw detail",
+          },
+          "list-scope-upgrade-pending",
+        ],
+        [
+          {
+            NEMOCLAW_LIST_EXIT_CODE: "1",
+            NEMOCLAW_LIST_STDERR: "device pairing required raw detail",
+          },
+          "list-device-pairing-required",
+        ],
+        [
+          {
+            NEMOCLAW_LIST_EXIT_CODE: "1",
+            NEMOCLAW_LIST_STDERR: "gateway connect failed raw detail",
+          },
+          "list-gateway-connect-failed",
+        ],
+        [{ NEMOCLAW_LIST_STDOUT: "" }, "list-empty-output"],
+        [{ NEMOCLAW_LIST_STDOUT: "raw invalid json" }, "list-invalid-json"],
+        [{ NEMOCLAW_LIST_STDOUT: "[]\n" }, "list-invalid-output"],
+        [{ NEMOCLAW_LIST_STDOUT: "{}\n" }, "list-missing-pending"],
+      ] as const) {
+        const result = spawnSync("sh", ["-c", script], {
+          encoding: "utf-8",
+          env: {
+            ...process.env,
+            PATH: `${tmpDir}:/usr/bin:/bin`,
+            ...environment,
+          },
+          timeout: 10_000,
+        });
+        expect(parseAutoPairApprovalReceipt(result.stdout)).toBe(receipt);
+        expect(`${result.stdout}${result.stderr}`).not.toContain("raw ");
+      }
+    } finally {
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    }
+  });
+
+  it("distinguishes host execution failures without returning their details", () => {
+    const timeoutError = Object.assign(new Error("private timeout detail"), {
+      code: "ETIMEDOUT",
+    });
+    const spawnError = Object.assign(new Error("private spawn detail"), { code: "ENOENT" });
+
+    expect(
+      classifyAutoPairApprovalExecReceipt(
+        { error: timeoutError, status: null, signal: "SIGTERM" },
+        "private output",
+      ),
+    ).toBe("exec-timeout");
+    expect(
+      classifyAutoPairApprovalExecReceipt(
+        { error: spawnError, status: null, signal: null },
+        "private output",
+      ),
+    ).toBe("exec-spawn-failed");
+    expect(
+      classifyAutoPairApprovalExecReceipt({ status: null, signal: "SIGKILL" }, "private output"),
+    ).toBe("exec-signal");
+    expect(classifyAutoPairApprovalExecReceipt({ status: 1, signal: null }, "private output")).toBe(
+      "exec-command-failed",
+    );
+    expect(classifyAutoPairApprovalExecReceipt({ status: 0, signal: null }, "private output")).toBe(
+      "exec-invalid-receipt",
+    );
+    expect(
+      classifyAutoPairApprovalExecReceipt(
+        { status: 0, signal: null },
+        "__NEMOCLAW_AUTO_PAIR_RECEIPT__=approved-one\n",
+      ),
+    ).toBe("approved-one");
+  });
+
+  it("streams the approval program through stdin instead of OpenShell command argv", () => {
+    const run = vi.fn(
+      (
+        _command: string,
+        _args: readonly string[],
+        _options: SpawnSyncOptionsWithStringEncoding,
+      ) => ({
+        status: 0,
+        signal: null,
+        stdout: "__NEMOCLAW_AUTO_PAIR_RECEIPT__=approved-one\n",
+        stderr: "",
+      }),
+    );
+
+    const result = runSandboxAutoPairApprovalPass(
+      "beta",
+      { localDeviceOnly: true, receipt: true },
+      {
+        getOpenshellBinary: () => "/usr/local/bin/openshell",
+        spawnSync: run as unknown as typeof spawnSync,
+      },
+    );
+
+    expect(result.receipt).toBe("approved-one");
+    expect(run).toHaveBeenCalledOnce();
+    expect(run.mock.calls[0]?.[1]).toEqual(["sandbox", "exec", "--name", "beta", "--", "sh", "-s"]);
+    expect(run.mock.calls[0]?.[1].join(" ")).not.toContain("PYAPPROVE");
+    expect(run.mock.calls[0]?.[2]).toEqual(
+      expect.objectContaining({
+        input: expect.stringContaining("PYAPPROVE"),
+        stdio: ["pipe", "pipe", "pipe"],
+      }),
+    );
+  });
+});

src/lib/actions/sandbox/auto-pair-approval-restored-root.test.ts

@@ -0,0 +1,85 @@
+// SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import { spawnSync } from "node:child_process";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { describe, expect, it } from "vitest";
+
+import {
+  buildAutoPairApprovalScript,
+  parseAutoPairApprovalReceipt,
+  readAutoPairApprovalPolicyModule,
+} from "./auto-pair-approval";
+
+describe("restored-clone state-root traversal (#4616)", () => {
+  const pyIt =
+    spawnSync("sh", ["-c", "command -v python3"], { stdio: "ignore" }).status === 0 ? it : it.skip;
+
+  pyIt("traverses the clone layout when root read access is denied", () => {
+    const policy = readAutoPairApprovalPolicyModule();
+    expect(policy).toBeTruthy();
+    const restoredClonePolicy = `${policy}
+import errno as _nemoclaw_test_errno
+import os as _nemoclaw_test_os
+_nemoclaw_test_original_open = _nemoclaw_test_os.open
+_nemoclaw_test_synthetic_path_flag = not hasattr(_nemoclaw_test_os, 'O_PATH')
+_nemoclaw_test_path_flag = getattr(_nemoclaw_test_os, 'O_PATH', 1 << 30)
+if _nemoclaw_test_synthetic_path_flag:
+    _nemoclaw_test_os.O_PATH = _nemoclaw_test_path_flag
+
+def _nemoclaw_test_open(path_value, flags, mode=0o777, *, dir_fd=None):
+    if (
+        dir_fd is None
+        and _nemoclaw_test_os.fspath(path_value) == _nemoclaw_test_os.sep
+        and not flags & _nemoclaw_test_path_flag
+    ):
+        raise PermissionError(
+            _nemoclaw_test_errno.EACCES,
+            'restored clone denies a read-directory handle for the filesystem root',
+        )
+    effective_flags = (
+        flags & ~_nemoclaw_test_path_flag
+        if _nemoclaw_test_synthetic_path_flag
+        else flags
+    )
+    return _nemoclaw_test_original_open(path_value, effective_flags, mode, dir_fd=dir_fd)
+
+_nemoclaw_test_os.open = _nemoclaw_test_open
+`;
+    const script = buildAutoPairApprovalScript(
+      Buffer.from(restoredClonePolicy, "utf-8").toString("base64"),
+      {
+        emitReceipt: true,
+        localDeviceOnly: true,
+        budget: { maxApprovals: 1 },
+      },
+    );
+    const legacyScript = script.replace("getattr(os, 'O_PATH', os.O_RDONLY)", "os.O_RDONLY");
+    const tmpDir = fs.realpathSync(
+      fs.mkdtempSync(path.join(os.tmpdir(), "nemoclaw-restored-root-")),
+    );
+    try {
+      const stateDir = path.join(tmpDir, "sandbox", ".openclaw");
+      fs.mkdirSync(path.join(stateDir, "devices"), { recursive: true });
+      fs.writeFileSync(path.join(tmpDir, "openclaw"), "#!/bin/sh\nexit 0\n", { mode: 0o755 });
+      const run = (approvalScript: string) =>
+        spawnSync("sh", {
+          encoding: "utf-8",
+          input: approvalScript,
+          env: {
+            ...process.env,
+            PATH: `${tmpDir}:/usr/bin:/bin`,
+            OPENCLAW_STATE_DIR: stateDir,
+          },
+          timeout: 10_000,
+        });
+
+      expect(parseAutoPairApprovalReceipt(run(legacyScript).stdout)).toBe("list-state-root-failed");
+      expect(parseAutoPairApprovalReceipt(run(script).stdout)).toBe("list-pending-unavailable");
+    } finally {
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    }
+  });
+});

src/lib/actions/sandbox/auto-pair-approval-script.test.ts

@@ -67,10 +67,10 @@ describe("buildAutoPairApprovalScript (#4263/#4616)", () => {
     expect(restoredClone).toContain("local_approval_auth_mode == 'paired-token'");
     expect(restoredClone).toContain("sync_approved_clone_device_auth");
     expect(restoredClone).toContain("os.O_DIRECTORY | os.O_NOFOLLOW");
+    expect(restoredClone).toContain("getattr(os, 'O_PATH', os.O_RDONLY)");
     expect(restoredClone).toContain("dir_fd=clone_state_dir_fd");
     expect(restoredClone).toContain("clone_devices_dir_fd,");
     expect(restoredClone).toContain("clone_identity_dir_fd,");
-    expect(restoredClone).toContain("metadata.st_nlink != 1");
     expect(restoredClone).toContain("pass_fds=approval_pass_fds");
     expect(restoredClone).toContain("approve_env['NODE_DISABLE_COMPILE_CACHE'] = '1'");
     expect(restoredClone).toContain("approve_env['OPENCLAW_NO_RESPAWN'] = '1'");
@@ -113,6 +113,13 @@ describe("buildAutoPairApprovalScript (#4263/#4616)", () => {
     for (const receipt of [
       "approved-one",
       "list-failed",
+      "list-state-path-invalid",
+      "list-platform-unsupported",
+      "list-state-root-failed",
+      "list-devices-directory-failed",
+      "list-pending-unsafe",
+      "list-pending-unstable",
+      "list-pending-invalid-shape",
       "list-pending-unavailable",
       "list-timeout",
       "list-exec-failed",