Auto-merge upstream openclaw/openclaw

Author: friuns2

apps/shared/OpenClawKit/Sources/OpenClawKit/NetworkInterfaceIPv4.swift

@@ -17,14 +17,14 @@ public enum NetworkInterfaceIPv4 {
             let flags = Int32(ptr.pointee.ifa_flags)
             let isUp = (flags & IFF_UP) != 0
             let isLoopback = (flags & IFF_LOOPBACK) != 0
-            let family = ptr.pointee.ifa_addr.pointee.sa_family
-            if !isUp || isLoopback || family != UInt8(AF_INET) { continue }
+            guard isUp, !isLoopback, let addrPtr = ptr.pointee.ifa_addr,
+                  addrPtr.pointee.sa_family == UInt8(AF_INET) else { continue }
 
-            var addr = ptr.pointee.ifa_addr.pointee
+            var addr = addrPtr.pointee
             var buffer = [CChar](repeating: 0, count: Int(NI_MAXHOST))
             let result = getnameinfo(
                 &addr,
-                socklen_t(ptr.pointee.ifa_addr.pointee.sa_len),
+                socklen_t(addrPtr.pointee.sa_len),
                 &buffer,
                 socklen_t(buffer.count),
                 nil,

config/assertion-safety-baseline.txt

@@ -4263,6 +4263,6 @@ ui/src/pages/workboard/view-card-actions.ts	2
 ui/src/pages/workboard/view-card-details.ts	1
 ui/src/pages/workboard/view-card-modal.ts	1
 ui/src/pages/workboard/view-card.ts	1
-ui/src/pages/workboard/view.ts	2
+ui/src/pages/workboard/view.ts	1
 ui/src/pages/workboard/workboard-select.ts	1
 ui/src/pages/worktrees/worktrees-page.ts	3

extensions/browser/src/browser/chrome.default-browser.test.ts

@@ -232,6 +232,52 @@ describe("browser default executable detection", () => {
     expect(exe?.path).toContain("Google Chrome.app/Contents/MacOS/Google Chrome");
   });
 
+  it("preserves vendor-first macOS browser discovery across system and user applications", () => {
+    vi.mocked(fs.existsSync).mockReturnValue(false);
+
+    expect(
+      resolveBrowserExecutableForPlatform(
+        {} as Parameters<typeof resolveBrowserExecutableForPlatform>[0],
+        "darwin",
+      ),
+    ).toBeNull();
+    expect(
+      vi
+        .mocked(fs.existsSync)
+        .mock.calls.map(([candidate]) => String(candidate))
+        .filter((candidate) => candidate.includes(".app/Contents/MacOS/")),
+    ).toEqual([
+      "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+      "/Users/test/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+      "/Applications/Brave Browser.app/Contents/MacOS/Brave Browser",
+      "/Users/test/Applications/Brave Browser.app/Contents/MacOS/Brave Browser",
+      "/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge",
+      "/Users/test/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge",
+      "/Applications/Chromium.app/Contents/MacOS/Chromium",
+      "/Users/test/Applications/Chromium.app/Contents/MacOS/Chromium",
+      "/Applications/Google Chrome Canary.app/Contents/MacOS/Google Chrome Canary",
+      "/Users/test/Applications/Google Chrome Canary.app/Contents/MacOS/Google Chrome Canary",
+    ]);
+  });
+
+  it.each([
+    ["chrome", "Google Chrome"],
+    ["brave", "Brave Browser"],
+    ["edge", "Microsoft Edge"],
+    ["chromium", "Chromium"],
+    ["canary", "Google Chrome Canary"],
+  ])("preserves the %s kind for a user-installed macOS browser", (kind, appName) => {
+    const expectedPath = `/Users/test/Applications/${appName}.app/Contents/MacOS/${appName}`;
+    vi.mocked(fs.existsSync).mockImplementation((candidate) => String(candidate) === expectedPath);
+
+    expect(
+      resolveBrowserExecutableForPlatform(
+        {} as Parameters<typeof resolveBrowserExecutableForPlatform>[0],
+        "darwin",
+      ),
+    ).toEqual({ kind, path: expectedPath });
+  });
+
   it("resolves an Opera default-browser launcher to the directly owned binary on Windows", () => {
     const installDir = "C:\\Users\\test\\AppData\\Local\\Programs\\Opera";
     const launcher = `${installDir}\\launcher.exe`;

extensions/browser/src/browser/chrome.executables.ts

@@ -612,54 +612,20 @@ function readSortedDirNames(dir: string): string[] {
 
 /** Find the best Chromium-family executable on macOS. */
 function findChromeExecutableMac(): BrowserExecutable | null {
-  const candidates: Array<BrowserExecutable> = [
-    {
-      kind: "chrome",
-      path: "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
-    },
-    {
-      kind: "chrome",
-      path: path.join(os.homedir(), "Applications/Google Chrome.app/Contents/MacOS/Google Chrome"),
-    },
-    {
-      kind: "brave",
-      path: "/Applications/Brave Browser.app/Contents/MacOS/Brave Browser",
-    },
-    {
-      kind: "brave",
-      path: path.join(os.homedir(), "Applications/Brave Browser.app/Contents/MacOS/Brave Browser"),
-    },
-    {
-      kind: "edge",
-      path: "/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge",
-    },
-    {
-      kind: "edge",
-      path: path.join(
-        os.homedir(),
-        "Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge",
-      ),
-    },
-    {
-      kind: "chromium",
-      path: "/Applications/Chromium.app/Contents/MacOS/Chromium",
-    },
-    {
-      kind: "chromium",
-      path: path.join(os.homedir(), "Applications/Chromium.app/Contents/MacOS/Chromium"),
-    },
-    {
-      kind: "canary",
-      path: "/Applications/Google Chrome Canary.app/Contents/MacOS/Google Chrome Canary",
-    },
-    {
-      kind: "canary",
-      path: path.join(
-        os.homedir(),
-        "Applications/Google Chrome Canary.app/Contents/MacOS/Google Chrome Canary",
-      ),
-    },
+  const applications: Array<[BrowserExecutable["kind"], string]> = [
+    ["chrome", "Google Chrome"],
+    ["brave", "Brave Browser"],
+    ["edge", "Microsoft Edge"],
+    ["chromium", "Chromium"],
+    ["canary", "Google Chrome Canary"],
   ];
+  const roots = ["/Applications", path.join(os.homedir(), "Applications")];
+  const candidates = applications.flatMap(([kind, name]) =>
+    roots.map((root) => ({
+      kind,
+      path: path.join(root, `${name}.app`, "Contents", "MacOS", name),
+    })),
+  );
 
   return findFirstExecutable(candidates, "darwin");
 }
@@ -721,68 +687,26 @@ function findGoogleChromeExecutableLinux(): BrowserExecutable | null {
 /** Find the best Chromium-family executable on Windows. */
 function findChromeExecutableWindows(): BrowserExecutable | null {
   const { localAppData, programFiles, programFilesX86 } = resolveWindowsBrowserInstallRoots();
-  const joinWin = path.win32.join;
-  const candidates: Array<BrowserExecutable> = [];
-
-  if (localAppData) {
-    // Chrome (user install)
-    candidates.push({
-      kind: "chrome",
-      path: joinWin(localAppData, "Google", "Chrome", "Application", "chrome.exe"),
-    });
-    // Brave (user install)
-    candidates.push({
-      kind: "brave",
-      path: joinWin(localAppData, "BraveSoftware", "Brave-Browser", "Application", "brave.exe"),
-    });
-    // Edge (user install)
-    candidates.push({
-      kind: "edge",
-      path: joinWin(localAppData, "Microsoft", "Edge", "Application", "msedge.exe"),
-    });
-    // Chromium (user install)
-    candidates.push({
-      kind: "chromium",
-      path: joinWin(localAppData, "Chromium", "Application", "chrome.exe"),
-    });
-    // Chrome Canary (user install)
-    candidates.push({
-      kind: "canary",
-      path: joinWin(localAppData, "Google", "Chrome SxS", "Application", "chrome.exe"),
-    });
+  const browsers: Array<[BrowserExecutable["kind"], ...string[]]> = [
+    ["chrome", "Google", "Chrome", "Application", "chrome.exe"],
+    ["brave", "BraveSoftware", "Brave-Browser", "Application", "brave.exe"],
+    ["edge", "Microsoft", "Edge", "Application", "msedge.exe"],
+    ["chromium", "Chromium", "Application", "chrome.exe"],
+    ["canary", "Google", "Chrome SxS", "Application", "chrome.exe"],
+  ];
+  const candidates: BrowserExecutable[] = localAppData
+    ? browsers.map(([kind, ...segments]) => ({
+        kind,
+        path: path.win32.join(localAppData, ...segments),
+      }))
+    : [];
+
+  for (const [kind, ...segments] of browsers.slice(0, 3)) {
+    for (const root of [programFiles, programFilesX86]) {
+      candidates.push({ kind, path: path.win32.join(root, ...segments) });
+    }
   }
 
-  // Chrome (system install, 64-bit)
-  candidates.push({
-    kind: "chrome",
-    path: joinWin(programFiles, "Google", "Chrome", "Application", "chrome.exe"),
-  });
-  // Chrome (system install, 32-bit on 64-bit Windows)
-  candidates.push({
-    kind: "chrome",
-    path: joinWin(programFilesX86, "Google", "Chrome", "Application", "chrome.exe"),
-  });
-  // Brave (system install, 64-bit)
-  candidates.push({
-    kind: "brave",
-    path: joinWin(programFiles, "BraveSoftware", "Brave-Browser", "Application", "brave.exe"),
-  });
-  // Brave (system install, 32-bit on 64-bit Windows)
-  candidates.push({
-    kind: "brave",
-    path: joinWin(programFilesX86, "BraveSoftware", "Brave-Browser", "Application", "brave.exe"),
-  });
-  // Edge (system install, 64-bit)
-  candidates.push({
-    kind: "edge",
-    path: joinWin(programFiles, "Microsoft", "Edge", "Application", "msedge.exe"),
-  });
-  // Edge (system install, 32-bit on 64-bit Windows)
-  candidates.push({
-    kind: "edge",
-    path: joinWin(programFilesX86, "Microsoft", "Edge", "Application", "msedge.exe"),
-  });
-
   return findFirstExecutable(candidates, "win32");
 }
 

extensions/browser/src/browser/routes/agent.storage.device.test.ts

@@ -3,8 +3,10 @@ import { createBrowserRouteApp, createBrowserRouteResponse } from "./test-helper
 import type { BrowserRequest } from "./types.js";
 
 const routeState = vi.hoisted(() => ({
+  cookiesGetViaPlaywright: vi.fn(async () => ({ cookies: [] })),
   cookiesSetManyViaPlaywright: vi.fn(async () => ({ added: 2 })),
   setDeviceViaPlaywright: vi.fn(async () => {}),
+  setHttpCredentialsViaPlaywright: vi.fn(async () => {}),
   withPlaywrightRouteContext: vi.fn(),
 }));
 
@@ -25,8 +27,10 @@ type PlaywrightRouteParams = {
     tab: { targetId: string };
     signal: AbortSignal;
     pw: {
+      cookiesGetViaPlaywright: typeof routeState.cookiesGetViaPlaywright;
       cookiesSetManyViaPlaywright: typeof routeState.cookiesSetManyViaPlaywright;
       setDeviceViaPlaywright: typeof routeState.setDeviceViaPlaywright;
+      setHttpCredentialsViaPlaywright: typeof routeState.setHttpCredentialsViaPlaywright;
     };
   }) => Promise<unknown>;
 };
@@ -39,25 +43,21 @@ function getPostHandler(route: string) {
   return handler;
 }
 
-describe("browser device route", () => {
-  beforeEach(() => {
-    routeState.cookiesSetManyViaPlaywright.mockClear();
-    routeState.setDeviceViaPlaywright.mockClear();
-    routeState.withPlaywrightRouteContext
-      .mockReset()
-      .mockImplementation(async (params: PlaywrightRouteParams) => {
-        await params.run({
-          cdpUrl: "http://127.0.0.1:18800",
-          tab: { targetId: "tab-1" },
-          signal: params.req.signal ?? new AbortController().signal,
-          pw: {
-            cookiesSetManyViaPlaywright: routeState.cookiesSetManyViaPlaywright,
-            setDeviceViaPlaywright: routeState.setDeviceViaPlaywright,
-          },
-        });
+beforeEach(() => {
+  vi.clearAllMocks();
+  routeState.withPlaywrightRouteContext
+    .mockReset()
+    .mockImplementation(async (params: PlaywrightRouteParams) => {
+      await params.run({
+        cdpUrl: "http://127.0.0.1:18800",
+        tab: { targetId: "tab-1" },
+        signal: params.req.signal ?? new AbortController().signal,
+        pw: routeState,
       });
-  });
+    });
+});
 
+describe("browser device route", () => {
   it("forwards the route lease signal into the atomic device transition", async () => {
     const controller = new AbortController();
     const response = createBrowserRouteResponse();
@@ -79,27 +79,36 @@ describe("browser device route", () => {
       signal: controller.signal,
     });
     expect(response.body).toEqual({ ok: true, targetId: "tab-1" });
+    expect(routeState.withPlaywrightRouteContext).toHaveBeenCalledWith(
+      expect.objectContaining({ feature: "device emulation" }),
+    );
+    expect(routeState.withPlaywrightRouteContext.mock.calls[0]?.[0]).not.toHaveProperty(
+      "enforceCurrentUrlAllowed",
+    );
   });
-});
 
-describe("browser cookie batch route", () => {
-  beforeEach(() => {
-    routeState.cookiesSetManyViaPlaywright.mockClear();
-    routeState.withPlaywrightRouteContext
-      .mockReset()
-      .mockImplementation(async (params: PlaywrightRouteParams) => {
-        await params.run({
-          cdpUrl: "http://127.0.0.1:18800",
-          tab: { targetId: "tab-1" },
-          signal: params.req.signal ?? new AbortController().signal,
-          pw: {
-            cookiesSetManyViaPlaywright: routeState.cookiesSetManyViaPlaywright,
-            setDeviceViaPlaywright: routeState.setDeviceViaPlaywright,
-          },
-        });
-      });
+  it("never publishes a successful mutation after its route lease is canceled", async () => {
+    const controller = new AbortController();
+    const response = createBrowserRouteResponse();
+    routeState.setDeviceViaPlaywright.mockImplementationOnce(async () => controller.abort());
+
+    await expect(
+      getPostHandler("/set/device")?.(
+        {
+          params: {},
+          query: {},
+          body: { name: "iPhone 14" },
+          signal: controller.signal,
+        },
+        response.res,
+      ),
+    ).rejects.toThrow();
+
+    expect(response.body).toBeUndefined();
   });
+});
 
+describe("browser cookie batch route", () => {
   it("parses and injects a non-empty cookie batch", async () => {
     const controller = new AbortController();
     const response = createBrowserRouteResponse();
@@ -150,3 +159,43 @@ describe("browser cookie batch route", () => {
     expect(routeState.cookiesSetManyViaPlaywright).not.toHaveBeenCalled();
   });
 });
+
+describe("browser storage route boundaries", () => {
+  it("keeps cookie reads behind the current-tab URL guard", async () => {
+    const { app, getHandlers } = createBrowserRouteApp();
+    registerBrowserAgentStorageRoutes(app, {} as never);
+    const response = createBrowserRouteResponse();
+
+    await getHandlers.get("/cookies")?.({ params: {}, query: {} }, response.res);
+
+    expect(routeState.withPlaywrightRouteContext).toHaveBeenCalledWith(
+      expect.objectContaining({ feature: "cookies", enforceCurrentUrlAllowed: true }),
+    );
+    expect(response.body).toEqual({ ok: true, targetId: "tab-1", cookies: [] });
+  });
+
+  it("applies HTTP credentials without ever returning the password", async () => {
+    const response = createBrowserRouteResponse();
+
+    await getPostHandler("/set/credentials")?.(
+      {
+        params: {},
+        query: {},
+        body: { username: "browser-user", password: "sensitive-browser-password" },
+      },
+      response.res,
+    );
+
+    expect(routeState.setHttpCredentialsViaPlaywright).toHaveBeenCalledWith({
+      cdpUrl: "http://127.0.0.1:18800",
+      targetId: "tab-1",
+      username: "browser-user",
+      password: "sensitive-browser-password",
+      clear: false,
+    });
+    expect(response.body).toEqual({ ok: true, targetId: "tab-1" });
+    expect(routeState.withPlaywrightRouteContext).toHaveBeenCalledWith(
+      expect.objectContaining({ feature: "http credentials" }),
+    );
+  });
+});