源码快照 @ 2026-09-02 (source-only, 剔除非源码素材)

evals/specs/windows-workspace-root-boundaries.test.ts

@@ -0,0 +1,90 @@
+import { expect } from "vitest";
+import { briefTest, claim, testBrief } from "@openwork/testkit";
+import { normalizeWorkspaceRootPath } from "../../packages/paths/index.mjs";
+import { prepareRuntimeWorkspaceRoot } from "../../apps/desktop/electron/runtime.mjs";
+
+briefTest(testBrief({
+  behavior: "Windows workspace roots stay within filesystem path boundaries and fail recoverably when unavailable.",
+  claims: {
+    verbatimNormalization: claim("valid verbatim drive and UNC roots normalize to ordinary Windows filesystem paths", {
+      never: "retain a Windows device namespace prefix",
+    }),
+    deviceRejection: claim("Win32 device namespace roots are rejected", {
+      never: "treat named pipes or physical devices as workspaces",
+    }),
+    disconnectedRetention: claim("a normal disconnected drive root remains unchanged", {
+      never: "resolve it against a different drive or consult its availability during normalization",
+    }),
+    inaccessibleRecovery: claim("an inaccessible root reports workspace_inaccessible and can be retried", {
+      never: "surface the injected filesystem error unwrapped or lose the requested workspace path",
+    }),
+  },
+}), async ({ prove }) => {
+  const driveRoot = normalizeWorkspaceRootPath("\\\\?\\C:\\Users\\Ada\\Workspace", { platform: "win32" });
+  const uncRoot = normalizeWorkspaceRootPath("\\\\?\\UNC\\server\\share\\Workspace", { platform: "win32" });
+  expect(driveRoot).toBe("C:\\Users\\Ada\\Workspace");
+  expect(uncRoot).toBe("\\\\server\\share\\Workspace");
+  expect(driveRoot).not.toMatch(/^\\\\[?.]\\/);
+  expect(uncRoot).not.toMatch(/^\\\\[?.]\\/);
+  prove.verbatimNormalization(
+    true,
+    `The verbatim drive normalized to ${driveRoot} and the verbatim UNC root normalized to ${uncRoot}; neither retained a device namespace prefix.`,
+  );
+
+  const deviceRoots = [
+    "\\\\.\\pipe\\openwork",
+    "//./PIPE/openwork",
+    "\\\\.\\PhysicalDrive0",
+  ];
+  for (const deviceRoot of deviceRoots) {
+    let thrown: unknown;
+    try {
+      normalizeWorkspaceRootPath(deviceRoot, { platform: "win32" });
+    } catch (error) {
+      thrown = error;
+    }
+    expect(thrown).toBeInstanceOf(TypeError);
+    expect(thrown).toMatchObject({ code: "invalid_workspace_root" });
+  }
+  prove.deviceRejection(
+    true,
+    `All ${deviceRoots.length} injected device namespace roots threw TypeError with invalid_workspace_root instead of becoming workspaces.`,
+  );
+
+  const disconnectedRoot = "Z:\\Disconnected\\Workspace";
+  const retainedRoot = normalizeWorkspaceRootPath(disconnectedRoot, { platform: "win32" });
+  expect(retainedRoot).toBe(disconnectedRoot);
+  expect(retainedRoot).not.toMatch(/^C:/i);
+  prove.disconnectedRetention(
+    true,
+    `${disconnectedRoot} was retained byte-for-byte and was not resolved onto the current drive.`,
+  );
+
+  const rawInaccessibleRoot = "\\\\?\\Z:\\Disconnected\\Workspace";
+  const normalizedInaccessibleRoot = "Z:\\Disconnected\\Workspace";
+  const filesystemError = Object.assign(new Error("drive is unavailable"), { code: "ENOENT" });
+  const attemptedRoots: string[] = [];
+  await expect(prepareRuntimeWorkspaceRoot(rawInaccessibleRoot, {
+    platform: "win32",
+    mkdirImpl: async (workspaceRoot: string) => {
+      attemptedRoots.push(workspaceRoot);
+      throw filesystemError;
+    },
+  })).rejects.toMatchObject({
+    code: "workspace_inaccessible",
+    workspacePath: rawInaccessibleRoot,
+    cause: filesystemError,
+  });
+  const retriedRoot = await prepareRuntimeWorkspaceRoot(rawInaccessibleRoot, {
+    platform: "win32",
+    mkdirImpl: async (workspaceRoot: string) => {
+      attemptedRoots.push(workspaceRoot);
+    },
+  });
+  expect(attemptedRoots).toEqual([normalizedInaccessibleRoot, normalizedInaccessibleRoot]);
+  expect(retriedRoot).toBe(normalizedInaccessibleRoot);
+  prove.inaccessibleRecovery(
+    true,
+    `The injected ENOENT was wrapped as workspace_inaccessible for ${rawInaccessibleRoot}; a retry targeted ${normalizedInaccessibleRoot} again and succeeded.`,
+  );
+});