@baique/pi-web-sky 0.1.35 → 0.1.36

package/lib/directory-browser.test.mjs

@@ -0,0 +1,60 @@
+import assert from "node:assert/strict";
+import { mkdtemp, mkdir, rm, symlink, writeFile } from "node:fs/promises";
+import { homedir, tmpdir } from "node:os";
+import path from "node:path";
+import test from "node:test";
+
+async function loadSubject() {
+  return import("./directory-browser.ts");
+}
+
+test("lists directories and directory symlinks without returning files", async () => {
+  const root = await mkdtemp(path.join(tmpdir(), "pi-web-browse-"));
+  try {
+    await mkdir(path.join(root, "project"));
+    await writeFile(path.join(root, "notes.txt"), "test", "utf8");
+    await symlink(path.join(root, "project"), path.join(root, "linked-project"));
+
+    const { listDirectories } = await loadSubject();
+    const directories = await listDirectories(root);
+
+    assert.deepEqual(directories.map((entry) => entry.name), ["linked-project", "project"]);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test("expands home-relative paths and rejects missing directories", async () => {
+  const {
+    getBrowseStartDirectory,
+    normalizeDirectory,
+    resolveDirectory,
+    shouldShowWindowsDrivePicker,
+  } = await loadSubject();
+  assert.equal(getBrowseStartDirectory(), homedir());
+  assert.equal(getBrowseStartDirectory("/project"), "/project");
+  assert.equal(shouldShowWindowsDrivePicker(undefined, "win32"), true);
+  assert.equal(shouldShowWindowsDrivePicker(undefined, "darwin"), false);
+  assert.equal(shouldShowWindowsDrivePicker(undefined, "linux"), false);
+  assert.equal(shouldShowWindowsDrivePicker("C:\\Projects", "win32"), false);
+  assert.equal(normalizeDirectory("~/project"), path.join(homedir(), "project"));
+  await assert.rejects(resolveDirectory(path.join(tmpdir(), `pi-web-missing-${Date.now()}`)));
+});
+
+test("builds every Windows drive-letter candidate", async () => {
+  const { getWindowsDriveCandidates } = await loadSubject();
+  const drives = getWindowsDriveCandidates();
+
+  assert.equal(drives.length, 26);
+  assert.deepEqual(drives[0], { name: "A:", path: "A:\\" });
+  assert.deepEqual(drives.at(-1), { name: "Z:", path: "Z:\\" });
+});
+
+test("finds parent directories across POSIX and Windows paths", async () => {
+  const { getParentDirectory } = await loadSubject();
+
+  assert.equal(getParentDirectory("/Users/alex/project"), "/Users/alex");
+  assert.equal(getParentDirectory("/"), null);
+  assert.equal(getParentDirectory("C:\\Users\\Alex\\project"), "C:\\Users\\Alex");
+  assert.equal(getParentDirectory("C:\\"), null);
+});

package/lib/directory-browser.ts

@@ -0,0 +1,83 @@
+import { readdir, realpath, stat } from "fs/promises";
+import { homedir } from "os";
+import path from "path";
+
+export interface BrowsableDirectory {
+  name: string;
+  path: string;
+}
+
+export function shouldShowWindowsDrivePicker(
+  directory?: string,
+  platform: NodeJS.Platform = process.platform,
+): boolean {
+  return platform === "win32" && !directory;
+}
+
+export function getBrowseStartDirectory(directory?: string): string {
+  return directory || homedir();
+}
+
+export function getWindowsDriveCandidates(): BrowsableDirectory[] {
+  return "ABCDEFGHIJKLMNOPQRSTUVWXYZ".split("").map((letter) => ({
+    name: `${letter}:`,
+    path: `${letter}:\\`,
+  }));
+}
+
+export async function listWindowsDrives(): Promise<BrowsableDirectory[]> {
+  const candidates = await Promise.all(getWindowsDriveCandidates().map(async (drive) => {
+    try {
+      const driveStat = await stat(drive.path);
+      return driveStat.isDirectory() ? drive : null;
+    } catch {
+      return null;
+    }
+  }));
+
+  return candidates.filter((drive): drive is BrowsableDirectory => drive !== null);
+}
+
+export function normalizeDirectory(directory: string): string {
+  if (directory === "~") return homedir();
+  if (directory.startsWith("~/")) return path.resolve(homedir(), directory.slice(2));
+  return path.resolve(directory);
+}
+
+export function getParentDirectory(directory: string): string | null {
+  const pathApi = /^[a-zA-Z]:[\\/]/.test(directory) || directory.startsWith("\\\\")
+    ? path.win32
+    : path.posix;
+  const normalized = pathApi.normalize(directory);
+  const parent = pathApi.dirname(normalized);
+  return parent === normalized ? null : parent;
+}
+
+export async function resolveDirectory(directory: string): Promise<string> {
+  return realpath(normalizeDirectory(directory));
+}
+
+export async function listDirectories(directory: string): Promise<BrowsableDirectory[]> {
+  const entries = await readdir(directory, { withFileTypes: true });
+  // 忽略损坏、不可访问或不指向目录的符号链接。
+  const candidates = await Promise.all(entries.map(async (entry) => {
+    if (entry.isDirectory()) {
+      return { name: entry.name, path: path.join(directory, entry.name) };
+    }
+    if (!entry.isSymbolicLink()) return null;
+
+    try {
+      const entryPath = path.join(directory, entry.name);
+      const realEntryPath = await realpath(entryPath);
+      const entryStat = await stat(realEntryPath);
+      if (!entryStat.isDirectory()) return null;
+      return { name: entry.name, path: entryPath };
+    } catch {
+      return null;
+    }
+  }));
+
+  return candidates
+    .filter((entry): entry is BrowsableDirectory => entry !== null)
+    .sort((left, right) => left.name.localeCompare(right.name));
+}

package/lib/draft-stash.test.mjs

@@ -0,0 +1,91 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { createJiti } from "jiti";
+
+const jiti = createJiti(import.meta.url, { tsconfigPaths: true });
+
+// Mock localStorage before importing the module-under-test.
+const store = new Map();
+globalThis.localStorage = {
+  getItem: (k) => (store.has(k) ? store.get(k) : null),
+  setItem: (k, v) => store.set(k, String(v)),
+  removeItem: (k) => store.delete(k),
+  clear: () => store.clear(),
+  key: (i) => Array.from(store.keys())[i] ?? null,
+  get length() { return store.size; },
+};
+
+const {
+  addDraft, updateDraft, removeDraft, loadDrafts, formatRelativeTime, newDraftId,
+} = await jiti.import("../lib/draft-stash.ts");
+
+test.beforeEach(() => store.clear());
+
+test("addDraft creates an item, persists it, and sorts newest first", () => {
+  const a = addDraft("第一条", 1000);
+  const b = addDraft("第二条", 2000);
+
+  const drafts = loadDrafts();
+  assert.equal(drafts.length, 2);
+  assert.equal(drafts[0].id, b.id);
+  assert.equal(drafts[0].content, "第二条");
+  assert.equal(drafts[1].content, "第一条");
+  assert.equal(typeof a.id, "string");
+  assert.ok(a.id.length > 0);
+});
+
+test("updateDraft rewrites content and moves the item to the top", () => {
+  const a = addDraft("原始内容", 1000);
+  addDraft("另一条", 2000);
+
+  const updated = updateDraft(a.id, "编辑后的内容", 3000);
+  assert.ok(updated);
+  assert.equal(updated.content, "编辑后的内容");
+  assert.equal(updated.updatedAt, 3000);
+
+  const drafts = loadDrafts();
+  assert.equal(drafts[0].id, a.id);
+  assert.equal(drafts[0].content, "编辑后的内容");
+});
+
+test("updateDraft returns null for an unknown id", () => {
+  assert.equal(updateDraft("missing-id", "x"), null);
+});
+
+test("removeDraft deletes only the target item", () => {
+  const a = addDraft("第一条", 1000);
+  const b = addDraft("第二条", 2000);
+
+  removeDraft(a.id);
+  const drafts = loadDrafts();
+  assert.equal(drafts.length, 1);
+  assert.equal(drafts[0].id, b.id);
+});
+
+test("loadDrafts survives corrupted storage", () => {
+  store.set("pi-web.drafts.v1", "{{{not json");
+  assert.deepEqual(loadDrafts(), []);
+});
+
+test("loadDrafts survives non-array / malformed entries", () => {
+  store.set("pi-web.drafts.v1", JSON.stringify([{ id: 1, content: "bad" }, "junk", { id: "ok", content: "fine", updatedAt: 5 }]));
+  const drafts = loadDrafts();
+  assert.equal(drafts.length, 1);
+  assert.equal(drafts[0].id, "ok");
+});
+
+test("formatRelativeTime produces compact labels", () => {
+  // 本地时区构造（实现按本地时间显示，断言保持一致）
+  const now = new Date(2026, 7, 18, 12, 0, 0).getTime(); // 2026-08-18 12:00 本地
+  assert.equal(formatRelativeTime(now - 5_000, now), "刚刚");
+  assert.equal(formatRelativeTime(now - 5 * 60_000, now), "5分钟前");
+  assert.equal(formatRelativeTime(now - 3 * 3_600_000, now), "09:00");
+  assert.equal(formatRelativeTime(now - 26 * 3_600_000, now), "昨天");
+  assert.equal(formatRelativeTime(new Date(2026, 7, 3, 9, 30).getTime(), now), "8月3日");
+  assert.equal(formatRelativeTime(new Date(2025, 11, 25, 9, 30).getTime(), now), "2025年12月25日");
+});
+
+test("newDraftId returns unique ids", () => {
+  const ids = new Set([newDraftId(), newDraftId(), newDraftId()]);
+  assert.equal(ids.size, 3);
+});

package/lib/draft-stash.ts

@@ -0,0 +1,102 @@
+// 用户级草稿暂存区：存储层（纯逻辑 + localStorage 封装）。
+// 跨会话、浏览器全局存在；内容只增不自动删，删除仅靠手动。
+// 与 lib/draft-store.ts（会话级单条输入框草稿）完全独立，互不干扰。
+
+export interface DraftItem {
+  id: string;
+  content: string;
+  updatedAt: number; // epoch ms
+}
+
+const STORAGE_KEY = "pi-web.drafts.v1";
+
+function getStorage(): Storage | null {
+  return typeof localStorage !== "undefined" ? localStorage : null;
+}
+
+function isDraftItem(value: unknown): value is DraftItem {
+  if (typeof value !== "object" || value === null) return false;
+  const v = value as Record<string, unknown>;
+  return (
+    typeof v.id === "string" &&
+    typeof v.content === "string" &&
+    typeof v.updatedAt === "number"
+  );
+}
+
+/** 生成草稿 id（优先 crypto.randomUUID，退化到时间戳+随机） */
+export function newDraftId(): string {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+    return crypto.randomUUID();
+  }
+  return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+}
+
+/** 读取全部草稿，按最近活动（updatedAt）降序；存储缺失/损坏时返回空数组 */
+export function loadDrafts(): DraftItem[] {
+  const storage = getStorage();
+  if (!storage) return [];
+  try {
+    const raw = storage.getItem(STORAGE_KEY);
+    if (!raw) return [];
+    const parsed: unknown = JSON.parse(raw);
+    if (!Array.isArray(parsed)) return [];
+    return parsed
+      .filter(isDraftItem)
+      .sort((a, b) => b.updatedAt - a.updatedAt);
+  } catch {
+    return [];
+  }
+}
+
+function saveDrafts(items: DraftItem[]): void {
+  const storage = getStorage();
+  if (!storage) return;
+  try {
+    storage.setItem(STORAGE_KEY, JSON.stringify(items));
+  } catch {
+    // 配额不足等——静默失败，草稿仅本次内存可见
+  }
+}
+
+/** 新增一条草稿，置顶 */
+export function addDraft(content: string, now: number = Date.now()): DraftItem {
+  const item: DraftItem = { id: newDraftId(), content, updatedAt: now };
+  saveDrafts([item, ...loadDrafts()]);
+  return item;
+}
+
+/** 更新一条草稿内容并置顶（最新编辑在最上方）；id 不存在返回 null */
+export function updateDraft(id: string, content: string, now: number = Date.now()): DraftItem | null {
+  const items = loadDrafts();
+  const idx = items.findIndex((d) => d.id === id);
+  if (idx < 0) return null;
+  const updated: DraftItem = { ...items[idx], content, updatedAt: now };
+  items.splice(idx, 1);
+  items.unshift(updated);
+  saveDrafts(items);
+  return updated;
+}
+
+/** 删除一条草稿（仅手动删除，无自动删除逻辑） */
+export function removeDraft(id: string): void {
+  saveDrafts(loadDrafts().filter((d) => d.id !== id));
+}
+
+function pad(n: number): string {
+  return n < 10 ? `0${n}` : String(n);
+}
+
+/** 相对时间简写：刚刚 / N分钟前 / HH:MM / 昨天 / M月D日 / YYYY年M月D日 */
+export function formatRelativeTime(ts: number, now: number = Date.now()): string {
+  const diff = now - ts;
+  if (diff < 60_000) return "刚刚";
+  if (diff < 3_600_000) return `${Math.floor(diff / 60_000)}分钟前`;
+  const d = new Date(ts);
+  const n = new Date(now);
+  const startOfToday = new Date(n.getFullYear(), n.getMonth(), n.getDate()).getTime();
+  if (ts >= startOfToday) return `${pad(d.getHours())}:${pad(d.getMinutes())}`;
+  if (ts >= startOfToday - 86_400_000) return "昨天";
+  if (d.getFullYear() === n.getFullYear()) return `${d.getMonth() + 1}月${d.getDate()}日`;
+  return `${d.getFullYear()}年${d.getMonth() + 1}月${d.getDate()}日`;
+}

package/lib/draft-store.ts

@@ -0,0 +1,105 @@
+import {
+  MAX_ATTACHED_IMAGES,
+  isBase64ImageWithinLimits,
+} from "./image-attachments";
+
+export interface ChatDraftImage {
+  data: string;
+  mimeType: string;
+}
+
+export interface ChatDraft {
+  value: string;
+  images: ChatDraftImage[];
+}
+
+const drafts = new Map<string, ChatDraft>();
+
+function cloneDraft(draft: ChatDraft): ChatDraft {
+  return {
+    value: draft.value,
+    images: draft.images.map((image) => ({ ...image })),
+  };
+}
+
+function isEmptyDraft(draft: ChatDraft): boolean {
+  return !draft.value && draft.images.length === 0;
+}
+
+export function getDraft(key: string): ChatDraft | null {
+  const draft = drafts.get(key);
+  return draft ? cloneDraft(draft) : null;
+}
+
+export function setDraft(key: string, draft: ChatDraft): void {
+  if (isEmptyDraft(draft)) {
+    drafts.delete(key);
+    return;
+  }
+  drafts.set(key, cloneDraft(draft));
+}
+
+export function clearDraft(key: string): void {
+  drafts.delete(key);
+}
+
+export function mergeRestoredSubmissionText(submitted: string, current: string): string {
+  if (!submitted.trim()) return current;
+  if (!current.trim()) return submitted;
+  return `${submitted}\n\n${current}`;
+}
+
+export function mergeRestoredSubmissionDraft(
+  submittedText: string,
+  submittedImages: ChatDraftImage[] | undefined,
+  currentText: string,
+  currentImages: ChatDraftImage[],
+): ChatDraft {
+  const images = [...(submittedImages ?? []), ...currentImages]
+    .filter(isBase64ImageWithinLimits)
+    .slice(0, MAX_ATTACHED_IMAGES)
+    .map(({ data, mimeType }) => ({ data, mimeType }));
+
+  return {
+    value: mergeRestoredSubmissionText(submittedText, currentText),
+    images,
+  };
+}
+
+export function restoreDraftSubmission(
+  key: string,
+  text: string,
+  images?: ChatDraftImage[],
+): ChatDraft {
+  const current = getDraft(key) ?? { value: "", images: [] };
+  const restored = mergeRestoredSubmissionDraft(
+    text,
+    images,
+    current.value,
+    current.images,
+  );
+  setDraft(key, restored);
+  return restored;
+}
+
+export function rekeyDraft(
+  previousKey: string,
+  nextKey: string,
+  currentDraft?: ChatDraft,
+): ChatDraft | null {
+  if (previousKey === nextKey) return currentDraft ? cloneDraft(currentDraft) : getDraft(nextKey);
+
+  const storedPrevious = getDraft(previousKey);
+  const previous = currentDraft && !isEmptyDraft(currentDraft)
+    ? cloneDraft(currentDraft)
+    : (storedPrevious ?? (currentDraft ? cloneDraft(currentDraft) : null));
+  const next = getDraft(nextKey);
+  clearDraft(previousKey);
+  if (!previous) return next;
+
+  const merged = next
+    ? mergeRestoredSubmissionDraft(next.value, next.images, previous.value, previous.images)
+    : previous;
+  setDraft(nextKey, merged);
+  return cloneDraft(merged);
+}

package/lib/dropdown-direction.ts

@@ -0,0 +1,27 @@
+// 下拉/气泡方向探测：距最近滚动容器下缘空间不足时向上展开（返回 true）。
+// 解决 absolute 定位弹层在滚动容器边缘被 overflow 裁剪的问题。
+
+export function dropdownDirection(
+  trigger: HTMLElement,
+  estimatedHeight: number,
+  offset = 4,
+): boolean {
+  let node = trigger.parentElement;
+  let container: Element | null = null;
+  while (node) {
+    const st = getComputedStyle(node);
+    if (st.overflowY === "auto" || st.overflowY === "scroll" || st.overflowY === "overlay") {
+      container = node;
+      break;
+    }
+    node = node.parentElement;
+  }
+  const t = trigger.getBoundingClientRect();
+  const c = container
+    ? container.getBoundingClientRect()
+    : { top: 0, bottom: window.innerHeight };
+  const spaceBelow = c.bottom - t.bottom;
+  const spaceAbove = t.top - c.top;
+  // 下方放不下且上方放得下 → 向上
+  return spaceBelow < estimatedHeight + offset && spaceAbove >= estimatedHeight + offset;
+}

package/lib/extension-command.test.mjs

@@ -0,0 +1,63 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+async function loadSubject() {
+  try {
+    const { createJiti } = await import("jiti");
+    return createJiti(import.meta.url).import("./extension-command.ts");
+  } catch {
+    return import("./extension-command.ts");
+  }
+}
+
+const {
+  nextInspectRequestId,
+  subscribeInspectReplies,
+  dispatchInspectReply,
+  clearPendingInspectReplies,
+} = await loadSubject();
+
+test("requestId 唯一且符合 [A-Za-z0-9_-]{1,64}", () => {
+  const a = nextInspectRequestId();
+  const b = nextInspectRequestId();
+  assert.notEqual(a, b);
+  assert.match(a, /^[A-Za-z0-9_-]{1,64}$/);
+});
+
+test("订阅-分发回包", () => {
+  clearPendingInspectReplies();
+  const received = [];
+  const unsubscribe = subscribeInspectReplies((reply, requestId) => {
+    received.push([reply, requestId]);
+  });
+  dispatchInspectReply({ kind: "pi-subagents.inspect-reply" }, "req-1");
+  assert.equal(received.length, 1);
+  assert.equal(received[0][1], "req-1");
+  unsubscribe();
+  dispatchInspectReply({}, "req-2");
+  assert.equal(received.length, 1, "退订后不再收到");
+  clearPendingInspectReplies();
+});
+
+test("单个监听器抛错不影响其他", () => {
+  clearPendingInspectReplies();
+  const received = [];
+  subscribeInspectReplies(() => {
+    throw new Error("boom");
+  });
+  subscribeInspectReplies((_, requestId) => received.push(requestId));
+  dispatchInspectReply({}, "req-3");
+  assert.deepEqual(received, ["req-3"]);
+  clearPendingInspectReplies();
+});
+
+test("迟到订阅者补收 pending 回包", () => {
+  clearPendingInspectReplies();
+  // 先分发（无订阅者），再订阅 → 应立即补收
+  dispatchInspectReply({ kind: "pi-subagents.inspect-reply" }, "late-req");
+  const received = [];
+  subscribeInspectReplies((reply, requestId) => received.push([reply, requestId]));
+  assert.equal(received.length, 1);
+  assert.equal(received[0][1], "late-req");
+  clearPendingInspectReplies();
+});

package/lib/extension-command.ts

@@ -0,0 +1,81 @@
+import { sendAgentCommand } from "./agent-client";
+
+/**
+ * inspect 命令封装：复用现有 prompt 通道执行 pi-subagents 的
+ * `/subagents-inspect-rpc` 扩展命令（SDK 的 _tryExecuteExtensionCommand 会
+ * 直接执行 handler，不走模型轮次）。
+ *
+ * 回包经 `subagent-inspect` widget emit-then-retract 两帧回传，由
+ * ExtensionStatusBar 拦截（见 components/ExtensionStatusBar.tsx），通过
+ * 模块级订阅分发。这里只负责构造命令 + 生成 requestId。
+ */
+
+let seq = 0;
+
+/** 生成符合插件侧 [A-Za-z0-9_-]{1,64} 约束的 requestId */
+export function nextInspectRequestId(): string {
+  seq = (seq + 1) % 0x7fffffff;
+  return `pw-${Date.now().toString(36)}-${seq.toString(36)}`;
+}
+
+/**
+ * 触发一次 inspect 查询。
+ * @param sessionId 当前会话 id
+ * @param requestId 本次请求的 requestId（与回包匹配）
+ * @param asyncId   子任务 run id（快照节点 id）
+ * @param childId   可选，workflow step / 嵌套子任务 id
+ * @param lines     可选，消息条数上限（1-200）
+ */
+export async function invokeSubagentInspect(
+  sessionId: string,
+  requestId: string,
+  asyncId: string,
+  childId?: string,
+  lines?: number,
+): Promise<void> {
+  const parts = ["/subagents-inspect-rpc", requestId, asyncId];
+  if (childId) parts.push(childId);
+  if (lines !== undefined) parts.push("--lines", String(lines));
+  await sendAgentCommand(sessionId, { type: "prompt", message: parts.join(" ") });
+}
+
+/** 模块级回包订阅：ExtensionStatusBar 收到 subagent-inspect 帧时调用。
+ * 回包先存 pending 缓存；订阅者订阅时立即补收匹配的回包，避免命令排队期间
+ * 卡片卸载导致回包丢失（emit-then-retract 帧是瞬时的，不缓存就会丢）。 */
+type InspectReplyListener = (reply: unknown, requestId: string) => void;
+const inspectReplyListeners = new Set<InspectReplyListener>();
+const pendingInspectReplies = new Map<string, unknown>();
+const PENDING_REPLY_TTL_MS = 60_000;
+
+export function subscribeInspectReplies(listener: InspectReplyListener): () => void {
+  inspectReplyListeners.add(listener);
+  // 补收订阅前已到达、尚未消费的回包
+  for (const [requestId, reply] of pendingInspectReplies) {
+    try {
+      listener(reply, requestId);
+    } catch {
+      // 单个监听器失败不影响其他监听器
+    }
+  }
+  return () => inspectReplyListeners.delete(listener);
+}
+
+/** 由 ExtensionStatusBar 调用，分发一次回包（并缓存，供迟到的订阅者补收） */
+export function dispatchInspectReply(reply: unknown, requestId: string): void {
+  pendingInspectReplies.set(requestId, reply);
+  setTimeout(() => {
+    if (pendingInspectReplies.get(requestId) === reply) pendingInspectReplies.delete(requestId);
+  }, PENDING_REPLY_TTL_MS);
+  for (const listener of inspectReplyListeners) {
+    try {
+      listener(reply, requestId);
+    } catch {
+      // 单个监听器失败不影响其他监听器
+    }
+  }
+}
+
+/** 清空 pending 缓存（测试用；生产不调用） */
+export function clearPendingInspectReplies(): void {
+  pendingInspectReplies.clear();
+}

package/lib/file-access.test.mjs

@@ -0,0 +1,31 @@
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import test from "node:test";
+
+// Loaded through jiti so the module's own extensionless imports resolve the way
+// the app resolves them (tsconfig moduleResolution: "bundler"); bare
+// `import("./path-security.ts")` only works while that file has no imports.
+async function loadSubject() {
+  const { createJiti } = await import("jiti");
+  return createJiti(import.meta.url).import("./path-security.ts");
+}
+
+test("rejects an existing path that escapes an allowed root through a symlink", async (t) => {
+  const { isExistingPathWithinRoots, isPathWithinRoots } = await loadSubject();
+  const base = fs.mkdtempSync(path.join(os.tmpdir(), "pi-web-file-access-"));
+  t.after(() => fs.rmSync(base, { recursive: true, force: true }));
+  const allowed = path.join(base, "allowed");
+  const outside = path.join(base, "outside");
+  fs.mkdirSync(allowed);
+  fs.mkdirSync(outside);
+  fs.writeFileSync(path.join(outside, "secret.txt"), "secret");
+  const link = path.join(allowed, "link");
+  fs.symlinkSync(outside, link, process.platform === "win32" ? "junction" : "dir");
+  const target = path.join(link, "secret.txt");
+  const roots = new Set([allowed]);
+
+  assert.equal(isPathWithinRoots(target, roots), true);
+  assert.equal(isExistingPathWithinRoots(target, roots), false);
+});