fix(doctor): canonicalize git checkout detection

giodl73-repo · steipete · commit 55a78711b944 · 2026-05-23T16:29:00.000+01:00
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -54,6 +54,7 @@ Docs: https://docs.openclaw.ai
 
 ### Fixes
 
+- Doctor/update: recognize junction-backed source checkouts as git installs by comparing canonical paths before showing package-manager update guidance. Fixes #82215. Thanks @igormf.
 - CLI/skills: show an all-ready note with next-step commands when skill setup has no missing dependencies to install. (#85032) Thanks @aniruddhaadak80.
 - Microsoft Foundry: route DeepSeek V4 Pro and Flash models through the Foundry Responses API while keeping older DeepSeek models on their existing path. (#85549) Thanks @roslinmahmud.
 - Status/usage: show configured cost estimates for AWS SDK models in full usage output while keeping token-only usage replies cost-free. (#85619) Thanks @ItsOtherMauridian.
diff --git a/src/commands/doctor-update.test.ts b/src/commands/doctor-update.test.ts
@@ -0,0 +1,111 @@
+import fs from "node:fs/promises";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { maybeOfferUpdateBeforeDoctor } from "./doctor-update.js";
+
+const originalStdinIsTtyDescriptor = Object.getOwnPropertyDescriptor(process.stdin, "isTTY");
+
+const mocks = vi.hoisted(() => ({
+  note: vi.fn(),
+  runCommandWithTimeout: vi.fn(),
+  runGatewayUpdate: vi.fn(),
+}));
+
+vi.mock("../process/exec.js", () => ({
+  runCommandWithTimeout: mocks.runCommandWithTimeout,
+}));
+
+vi.mock("../infra/update-runner.js", () => ({
+  runGatewayUpdate: mocks.runGatewayUpdate,
+}));
+
+vi.mock("../terminal/note.js", () => ({
+  note: mocks.note,
+}));
+
+async function runOffer(params?: {
+  root?: string;
+  confirm?: (p: { message: string; initialValue: boolean }) => Promise<boolean>;
+}): Promise<Awaited<ReturnType<typeof maybeOfferUpdateBeforeDoctor>>> {
+  const confirm = params?.confirm ?? vi.fn().mockResolvedValue(false);
+  return await maybeOfferUpdateBeforeDoctor({
+    runtime: {} as never,
+    options: {},
+    root: params?.root ?? "/repo/link",
+    confirm,
+    outro: vi.fn(),
+  });
+}
+
+beforeEach(async () => {
+  mocks.note.mockReset();
+  mocks.runCommandWithTimeout.mockReset();
+  mocks.runGatewayUpdate.mockReset();
+  Object.defineProperty(process.stdin, "isTTY", {
+    configurable: true,
+    value: true,
+  });
+});
+
+afterEach(() => {
+  vi.restoreAllMocks();
+  if (originalStdinIsTtyDescriptor) {
+    Object.defineProperty(process.stdin, "isTTY", originalStdinIsTtyDescriptor);
+  } else {
+    delete (process.stdin as Partial<typeof process.stdin>).isTTY;
+  }
+});
+
+describe("maybeOfferUpdateBeforeDoctor", () => {
+  it("treats a linked package root as a git checkout when realpaths match", async () => {
+    const confirm = vi.fn().mockResolvedValue(false);
+    vi.spyOn(fs, "realpath").mockImplementation(async (candidate) => {
+      const value = String(candidate);
+      if (value === "/repo/link" || value === "/repo/real") {
+        return "/repo/real";
+      }
+      return value;
+    });
+    mocks.runCommandWithTimeout.mockResolvedValue({
+      stdout: "/repo/real\n",
+      stderr: "",
+      code: 0,
+      killed: false,
+      signal: null,
+      termination: "exit",
+      noOutputTimedOut: false,
+    });
+
+    await expect(runOffer({ root: "/repo/link", confirm })).resolves.toEqual({ updated: false });
+
+    expect(confirm).toHaveBeenCalledWith({
+      message: "Update OpenClaw from git before running doctor?",
+      initialValue: true,
+    });
+    expect(mocks.note).not.toHaveBeenCalledWith(
+      expect.stringContaining("This install is not a git checkout."),
+      "Update",
+    );
+  });
+
+  it("keeps package-manager guidance when git reports a different checkout", async () => {
+    const confirm = vi.fn();
+    vi.spyOn(fs, "realpath").mockImplementation(async (candidate) => String(candidate));
+    mocks.runCommandWithTimeout.mockResolvedValue({
+      stdout: "/repo/other\n",
+      stderr: "",
+      code: 0,
+      killed: false,
+      signal: null,
+      termination: "exit",
+      noOutputTimedOut: false,
+    });
+
+    await expect(runOffer({ root: "/repo/link", confirm })).resolves.toEqual({ updated: false });
+
+    expect(confirm).not.toHaveBeenCalled();
+    expect(mocks.note).toHaveBeenCalledWith(
+      expect.stringContaining("This install is not a git checkout."),
+      "Update",
+    );
+  });
+});
diff --git a/src/commands/doctor-update.ts b/src/commands/doctor-update.ts
@@ -1,3 +1,5 @@
+import fs from "node:fs/promises";
+import path from "node:path";
 import { formatCliCommand } from "../cli/command-format.js";
 import { isTruthyEnvValue } from "../infra/env.js";
 import { runGatewayUpdate } from "../infra/update-runner.js";
@@ -7,6 +9,10 @@ import { normalizeLowercaseStringOrEmpty } from "../shared/string-coerce.js";
 import { note } from "../terminal/note.js";
 import type { DoctorOptions } from "./doctor-prompter.js";
 
+async function resolveComparablePath(target: string): Promise<string> {
+  return await fs.realpath(target).catch(() => path.resolve(target));
+}
+
 async function detectOpenClawGitCheckout(root: string): Promise<"git" | "not-git" | "unknown"> {
   const res = await runCommandWithTimeout(["git", "-C", root, "rev-parse", "--show-toplevel"], {
     timeoutMs: 5000,
@@ -22,7 +28,10 @@ async function detectOpenClawGitCheckout(root: string): Promise<"git" | "not-git
     }
     return "unknown";
   }
-  return res.stdout.trim() === root ? "git" : "not-git";
+  const gitRoot = res.stdout.trim();
+  return (await resolveComparablePath(gitRoot)) === (await resolveComparablePath(root))
+    ? "git"
+    : "not-git";
 }
 
 export async function maybeOfferUpdateBeforeDoctor(params: {
