@baique/pi-web-sky 0.1.35 → 0.1.36

package/lib/file-access.ts

@@ -0,0 +1,59 @@
+import { readdirSync } from "fs";
+import { homedir } from "os";
+import path from "path";
+import { getAdditionalAllowedRoots, normalizeSlashes } from "./allowed-roots";
+import { isExistingPathWithinRoots, isPathWithinRoots } from "./path-security";
+import { listAllSessions } from "./session-reader";
+export { allowFileRoot, normalizeSlashes } from "./allowed-roots";
+export { isWindowsAbsolutePath } from "./paths";
+
+// Short-TTL cache for the allowed-roots set. Without this, every file list/read
+// request re-scans every pi session on disk just to check access. 5s is short
+// enough that newly-created cwds appear promptly; stored on globalThis so it
+// survives Next.js hot-reload.
+declare global {
+  var __piAllowedRootsCache: { roots: Set<string>; expiresAt: number } | undefined;
+}
+
+const ALLOWED_ROOTS_TTL_MS = 5_000;
+
+export async function getAllowedFileRoots(): Promise<Set<string>> {
+  const now = Date.now();
+  const cached = globalThis.__piAllowedRootsCache;
+  if (cached && cached.expiresAt > now) return cached.roots;
+
+  const sessions = await listAllSessions();
+  const roots = new Set<string>();
+  for (const s of sessions) {
+    if (s.cwd) roots.add(normalizeSlashes(s.cwd));
+    // The project root (main repo shared by all worktrees) is browsable too —
+    // the project dropdown lists it even when only worktrees have sessions.
+    if (s.projectRoot) roots.add(normalizeSlashes(s.projectRoot));
+  }
+
+  // Also allow ~/pi-cwd-* directories created by the default-cwd endpoint.
+  try {
+    for (const name of readdirSync(homedir())) {
+      if (/^pi-cwd-\d{8}$/.test(name)) {
+        roots.add(normalizeSlashes(path.join(homedir(), name)));
+      }
+    }
+  } catch {
+    // ignore if home is unreadable
+  }
+
+  for (const root of getAdditionalAllowedRoots()) roots.add(root);
+
+  globalThis.__piAllowedRootsCache = { roots, expiresAt: now + ALLOWED_ROOTS_TTL_MS };
+  return roots;
+}
+
+/** Authorize a path lexically, without touching the filesystem. */
+export function isFilePathAllowed(target: string, allowedRoots: Set<string>): boolean {
+  return isPathWithinRoots(target, allowedRoots);
+}
+
+/** Authorize an existing path after resolving symbolic links. */
+export function isExistingFilePathAllowed(target: string, allowedRoots: Set<string>): boolean {
+  return isExistingPathWithinRoots(target, allowedRoots);
+}

package/lib/file-dirent.test.mjs

@@ -0,0 +1,56 @@
+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";
+
+async function loadSubject() {
+  return import("./file-dirent.ts");
+}
+
+test("uses Dirent types for regular files and directories", async () => {
+  const { resolveDirentIsDirectory } = await loadSubject();
+  const file = { isDirectory: () => false, isFile: () => true };
+  const directory = { isDirectory: () => true, isFile: () => false };
+
+  assert.equal(resolveDirentIsDirectory(file, "/unused/file"), false);
+  assert.equal(resolveDirentIsDirectory(directory, "/unused/directory"), true);
+});
+
+test("falls back to stat when the Dirent type is unknown", async (t) => {
+  const { resolveDirentIsDirectory } = await loadSubject();
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-web-dirent-"));
+  t.after(() => fs.rmSync(root, { recursive: true, force: true }));
+  const directoryPath = path.join(root, "directory");
+  fs.mkdirSync(directoryPath);
+
+  const unknown = { isDirectory: () => false, isFile: () => false };
+  assert.equal(resolveDirentIsDirectory(unknown, directoryPath), true);
+});
+
+test("follows directory symlinks and skips dangling symlinks", async (t) => {
+  const { resolveDirentIsDirectory } = await loadSubject();
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-web-dirent-"));
+  t.after(() => fs.rmSync(root, { recursive: true, force: true }));
+  fs.mkdirSync(path.join(root, "target"));
+  try {
+    fs.symlinkSync("target", path.join(root, "directory-link"), "dir");
+    fs.symlinkSync("missing", path.join(root, "dangling-link"), "file");
+  } catch (error) {
+    if (error?.code === "EPERM") {
+      t.skip("Creating symbolic links requires additional privileges on this platform");
+      return;
+    }
+    throw error;
+  }
+
+  const symlink = { isDirectory: () => false, isFile: () => false };
+  assert.equal(
+    resolveDirentIsDirectory(symlink, path.join(root, "directory-link")),
+    true,
+  );
+  assert.equal(
+    resolveDirentIsDirectory(symlink, path.join(root, "dangling-link")),
+    null,
+  );
+});

package/lib/file-dirent.ts

@@ -0,0 +1,17 @@
+import fs from "fs";
+
+type DirentType = Pick<fs.Dirent, "isDirectory" | "isFile">;
+
+export function resolveDirentIsDirectory(
+  dirent: DirentType,
+  fullPath: string,
+): boolean | null {
+  if (dirent.isDirectory()) return true;
+  if (dirent.isFile()) return false;
+
+  try {
+    return fs.statSync(fullPath).isDirectory();
+  } catch {
+    return null;
+  }
+}

package/lib/file-explorer-state.test.mjs

@@ -0,0 +1,63 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { createJiti } from "jiti";
+
+const jiti = createJiti(import.meta.url);
+const { loadExplorerOpen, saveExplorerOpen } = await jiti.import("./file-explorer-state.ts");
+
+function createStorage(initial = {}) {
+  const values = new Map(Object.entries(initial));
+  return {
+    values,
+    getItem(key) {
+      return values.get(key) ?? null;
+    },
+    setItem(key, value) {
+      values.set(key, value);
+    },
+  };
+}
+
+test("defaults to an open file explorer", () => {
+  assert.equal(loadExplorerOpen(createStorage()), true);
+});
+
+test("saves and restores the file explorer panel state", () => {
+  const storage = createStorage();
+
+  saveExplorerOpen(false, storage);
+  assert.equal(loadExplorerOpen(storage), false);
+
+  saveExplorerOpen(true, storage);
+  assert.equal(loadExplorerOpen(storage), true);
+});
+
+test("falls back to open when browser storage is unavailable", () => {
+  const unavailable = {
+    getItem() { throw new Error("blocked"); },
+    setItem() { throw new Error("blocked"); },
+  };
+
+  assert.equal(loadExplorerOpen(unavailable), true);
+  assert.doesNotThrow(() => saveExplorerOpen(false, unavailable));
+});
+
+test("falls back when accessing browser storage throws", () => {
+  const previousWindow = Object.getOwnPropertyDescriptor(globalThis, "window");
+  const blockedWindow = {};
+  Object.defineProperty(blockedWindow, "localStorage", {
+    get() { throw new DOMException("blocked", "SecurityError"); },
+  });
+  Object.defineProperty(globalThis, "window", {
+    configurable: true,
+    value: blockedWindow,
+  });
+
+  try {
+    assert.equal(loadExplorerOpen(), true);
+    assert.doesNotThrow(() => saveExplorerOpen(false));
+  } finally {
+    if (previousWindow) Object.defineProperty(globalThis, "window", previousWindow);
+    else delete globalThis.window;
+  }
+});

package/lib/file-explorer-state.ts

@@ -0,0 +1,36 @@
+const EXPLORER_OPEN_STORAGE_KEY = "pi-web:file-explorer:open";
+
+interface StorageLike {
+  getItem(key: string): string | null;
+  setItem(key: string, value: string): void;
+}
+
+function getBrowserStorage(): StorageLike | null {
+  if (typeof window === "undefined") return null;
+  try {
+    return window.localStorage;
+  } catch {
+    return null;
+  }
+}
+
+export function loadExplorerOpen(storage: StorageLike | null = getBrowserStorage()): boolean {
+  if (!storage) return true;
+  try {
+    return storage.getItem(EXPLORER_OPEN_STORAGE_KEY) !== "false";
+  } catch {
+    return true;
+  }
+}
+
+export function saveExplorerOpen(
+  open: boolean,
+  storage: StorageLike | null = getBrowserStorage(),
+): void {
+  if (!storage) return;
+  try {
+    storage.setItem(EXPLORER_OPEN_STORAGE_KEY, String(open));
+  } catch {
+    // Persistence is best-effort; privacy mode and storage quotas must not break the explorer.
+  }
+}

package/lib/file-fuzzy.test.mjs

@@ -0,0 +1,29 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+async function loadSubject() {
+  return import("./file-fuzzy.ts");
+}
+
+test("builds closed file mentions and quotes paths containing spaces", async () => {
+  const { buildAtMentionText, buildFileAtMentionsText } = await loadSubject();
+
+  assert.equal(buildAtMentionText("notes/todo.md", false), "@notes/todo.md ");
+  assert.equal(buildAtMentionText("project files/design brief.md", false), "@\"project files/design brief.md\" ");
+  assert.equal(
+    buildFileAtMentionsText(["notes/todo.md", "project files/design brief.md"]),
+    "@notes/todo.md @\"project files/design brief.md\" ",
+  );
+});
+
+test("builds line-scoped file mentions", async () => {
+  const { buildFileLineMentionText } = await loadSubject();
+
+  assert.equal(buildFileLineMentionText("src/app.ts", 12, 12), "@src/app.ts:12 ");
+  assert.equal(buildFileLineMentionText("src/app.ts", 18, 12), "@src/app.ts:12-18 ");
+  assert.equal(
+    buildFileLineMentionText("project files/app.ts", 3, 9),
+    "@\"project files/app.ts\":3-9 ",
+  );
+  assert.equal(buildFileLineMentionText("src/app.ts", 0, 0), "@src/app.ts:1 ");
+});

package/lib/file-fuzzy.ts

@@ -0,0 +1,189 @@
+// Pure helpers for the chat input's @ file autocomplete. Mirrors the pi TUI's
+// behavior: @ triggers at line start or after whitespace, entries are ranked
+// with the TUI's scoreEntry ladder, and completions insert "@relative/path ".
+
+export interface AtQueryMatch {
+  /** Index of the "@" character in the text */
+  start: number;
+  /** Text typed after the "@" (quotes stripped); may be empty */
+  query: string;
+  /** True when the token uses the @"..." quoted form */
+  quoted: boolean;
+}
+
+export interface FileIndexEntry {
+  /** Path relative to the session cwd, "/"-separated, no trailing slash */
+  path: string;
+  isDir: boolean;
+}
+
+/**
+ * Detect an @ file token immediately before the cursor. The @ must be at the
+ * start of the text or preceded by whitespace (same rule as the TUI), so
+ * emails like foo@bar never trigger. Supports the in-progress quoted form
+ * @"my dir/fi so drill-down into space-containing paths keeps working.
+ */
+export function extractAtQuery(textBeforeCursor: string): AtQueryMatch | null {
+  const quoted = /(?:^|\s)@"([^"\n]*)$/.exec(textBeforeCursor);
+  if (quoted) {
+    return {
+      start: textBeforeCursor.length - (quoted[1].length + 2),
+      query: quoted[1],
+      quoted: true,
+    };
+  }
+  const plain = /(?:^|\s)@([^\s"]*)$/.exec(textBeforeCursor);
+  if (plain) {
+    return {
+      start: textBeforeCursor.length - (plain[1].length + 1),
+      query: plain[1],
+      quoted: false,
+    };
+  }
+  return null;
+}
+
+function pathDepth(p: string): number {
+  let depth = 0;
+  for (let i = 0; i < p.length; i++) {
+    if (p[i] === "/") depth++;
+  }
+  return depth;
+}
+
+/**
+ * Build the entry list from the server's flat file list, deriving directory
+ * entries from file paths (the index API only returns files). Base order is
+ * shallow-first then alphabetical, which is what an empty @ query shows.
+ */
+export function buildEntriesFromFiles(files: string[]): FileIndexEntry[] {
+  const dirs = new Set<string>();
+  for (const f of files) {
+    let idx = f.indexOf("/");
+    while (idx !== -1) {
+      dirs.add(f.slice(0, idx));
+      idx = f.indexOf("/", idx + 1);
+    }
+  }
+  const entries: FileIndexEntry[] = [];
+  for (const d of dirs) entries.push({ path: d, isDir: true });
+  for (const f of files) {
+    if (!f) continue;
+    entries.push({ path: f, isDir: false });
+  }
+  entries.sort((a, b) => pathDepth(a.path) - pathDepth(b.path) || a.path.localeCompare(b.path));
+  return entries;
+}
+
+function isSubsequence(needle: string, haystack: string): boolean {
+  if (!needle) return true;
+  let i = 0;
+  for (let j = 0; j < haystack.length && i < needle.length; j++) {
+    if (haystack[j] === needle[i]) i++;
+  }
+  return i === needle.length;
+}
+
+/**
+ * TUI scoreEntry ladder (exact 100 / prefix 80 / substring 50 / path substring
+ * 30, directories +10) plus a low-weight subsequence fallback so genuinely
+ * fuzzy queries like "chinp" still find components/ChatInput.tsx.
+ *
+ * Queries containing "/" are ranked against the full relative path instead of
+ * the basename — this is what makes drill-down work: after inserting "@src/",
+ * the query "src/" prefix-matches every entry inside src/ (and excludes the
+ * src directory itself, since "src" does not start with "src/").
+ */
+function scoreEntry(entry: FileIndexEntry, lowerQuery: string): number {
+  const lowerPath = entry.path.toLowerCase();
+  let score = 0;
+  if (lowerQuery.includes("/")) {
+    if (lowerPath === lowerQuery) score = 100;
+    else if (lowerPath.startsWith(lowerQuery)) score = 80;
+    else if (lowerPath.includes(lowerQuery)) score = 50;
+    else if (isSubsequence(lowerQuery, lowerPath)) score = 10;
+  } else {
+    const slash = lowerPath.lastIndexOf("/");
+    const lowerName = slash === -1 ? lowerPath : lowerPath.slice(slash + 1);
+    if (lowerName === lowerQuery) score = 100;
+    else if (lowerName.startsWith(lowerQuery)) score = 80;
+    else if (lowerName.includes(lowerQuery)) score = 50;
+    else if (lowerPath.includes(lowerQuery)) score = 30;
+    else if (isSubsequence(lowerQuery, lowerPath)) score = 10;
+  }
+  if (entry.isDir && score > 0) score += 10;
+  return score;
+}
+
+export const AT_RESULT_LIMIT = 20;
+
+export function filterFileEntries(
+  entries: FileIndexEntry[],
+  query: string,
+  limit: number = AT_RESULT_LIMIT,
+): FileIndexEntry[] {
+  const lowerQuery = query.toLowerCase();
+  if (!lowerQuery) return entries.slice(0, limit);
+
+  const scored: Array<{ entry: FileIndexEntry; score: number }> = [];
+  for (const entry of entries) {
+    const score = scoreEntry(entry, lowerQuery);
+    if (score > 0) scored.push({ entry, score });
+  }
+  scored.sort((a, b) =>
+    b.score - a.score
+    || pathDepth(a.entry.path) - pathDepth(b.entry.path)
+    || a.entry.path.localeCompare(b.entry.path));
+  return scored.slice(0, limit).map((s) => s.entry);
+}
+
+export interface AtInsertion {
+  /** Text that replaces the @token */
+  text: string;
+  /** Caret position relative to the start of `text` after insertion */
+  cursorOffset: number;
+}
+
+/**
+ * Replacement for the @token when a suggestion is confirmed. Mirrors the
+ * TUI's buildCompletionValue/applyCompletion:
+ * - Files close the token: "@path " (quoted when the path contains spaces),
+ *   caret after the trailing space.
+ * - Directories keep the menu open for drill-down: "@dir/" with no trailing
+ *   space. Quoted directories are inserted CLOSED (@"my dir/") with the caret
+ *   placed before the closing quote, so both further typing and manual
+ *   completion keep the token well-formed.
+ */
+export function buildAtInsertText(entryPath: string, isDir: boolean, forceQuotes = false): AtInsertion {
+  const p = isDir ? `${entryPath}/` : entryPath;
+  const needsQuotes = forceQuotes || p.includes(" ");
+  if (isDir) {
+    const text = needsQuotes ? `@"${p}"` : `@${p}`;
+    return { text, cursorOffset: needsQuotes ? text.length - 1 : text.length };
+  }
+  const text = needsQuotes ? `@"${p}" ` : `@${p} `;
+  return { text, cursorOffset: text.length };
+}
+
+/**
+ * Closed @mention for one-shot inserts (e.g. the file explorer's @ button).
+ * Unlike buildAtInsertText there is no drill-down: directories are closed
+ * too, with a trailing "/" and a trailing space.
+ */
+export function buildAtMentionText(entryPath: string, isDir: boolean): string {
+  const p = isDir ? `${entryPath}/` : entryPath;
+  return p.includes(" ") ? `@"${p}" ` : `@${p} `;
+}
+
+/** Closed file @mention scoped to one logical line or an inclusive line range. */
+export function buildFileLineMentionText(entryPath: string, startLine: number, endLine: number): string {
+  const firstLine = Math.max(1, Math.min(startLine, endLine));
+  const lastLine = Math.max(1, Math.max(startLine, endLine));
+  const pathMention = entryPath.includes(" ") ? `@"${entryPath}"` : `@${entryPath}`;
+  const lineSuffix = firstLine === lastLine ? `:${firstLine}` : `:${firstLine}-${lastLine}`;
+  return `${pathMention}${lineSuffix} `;
+}
+
+export function buildFileAtMentionsText(entryPaths: string[]): string {
+  return entryPaths.map((entryPath) => buildAtMentionText(entryPath, false)).join("");
+}

package/lib/file-links.test.mjs

@@ -0,0 +1,92 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+async function loadSubject() {
+  return import("./file-links.ts");
+}
+
+test("resolves absolute markdown file links and strips line suffixes", async () => {
+  const { resolveLocalFileHref } = await loadSubject();
+
+  assert.equal(
+    resolveLocalFileHref(
+      "/home/me/project/components/MarkdownBody.tsx:36",
+      "/home/me/project",
+    ),
+    "/home/me/project/components/MarkdownBody.tsx",
+  );
+});
+
+test("resolves absolute file links outside cwd", async () => {
+  const { resolveLocalFileHref } = await loadSubject();
+
+  assert.equal(
+    resolveLocalFileHref(
+      "/home/me/.codex/config.toml:12",
+      "/home/me/project",
+    ),
+    "/home/me/.codex/config.toml",
+  );
+});
+
+test("resolves relative markdown file links against cwd", async () => {
+  const { resolveLocalFileHref } = await loadSubject();
+
+  assert.equal(
+    resolveLocalFileHref("components/AppShell.tsx#L42", "/home/me/project"),
+    "/home/me/project/components/AppShell.tsx",
+  );
+});
+
+test("does not let relative links escape cwd", async () => {
+  const { resolveLocalFileHref } = await loadSubject();
+
+  assert.equal(
+    resolveLocalFileHref("../outside.md", "/home/me/project"),
+    null,
+  );
+});
+
+test("resolves preview links from the file directory within the project root", async () => {
+  const { resolveLocalFileHref } = await loadSubject();
+
+  assert.equal(
+    resolveLocalFileHref("../file.js", "/home/me/project/docs/nested", "/home/me/project"),
+    "/home/me/project/docs/file.js",
+  );
+  assert.equal(
+    resolveLocalFileHref("../../../outside.js", "/home/me/project/docs/nested", "/home/me/project"),
+    null,
+  );
+});
+
+test("does not treat app or external URLs as file links", async () => {
+  const { resolveLocalFileHref } = await loadSubject();
+
+  assert.equal(resolveLocalFileHref("/api/files/home/me/project/a.ts", "/home/me/project"), null);
+  assert.equal(resolveLocalFileHref("https://example.com/a.ts", "/home/me/project"), null);
+  assert.equal(resolveLocalFileHref("ftp://example.com/a.ts", "/home/me/project"), null);
+  assert.equal(resolveLocalFileHref("//example.com/a.ts", "/home/me/project"), null);
+});
+
+test("resolves Windows file URLs without a synthetic leading slash", async () => {
+  const { resolveLocalFileHref } = await loadSubject();
+
+  assert.equal(
+    resolveLocalFileHref("file:///C:/Users/me/project/file.txt:10", "C:/Users/me/project"),
+    "C:/Users/me/project/file.txt",
+  );
+});
+
+test("resolves UNC file URLs and backslash UNC paths", async () => {
+  const { resolveLocalFileHref } = await loadSubject();
+
+  assert.equal(
+    resolveLocalFileHref("file://server/share/project/file.txt", "/home/me/project"),
+    "//server/share/project/file.txt",
+  );
+  assert.equal(
+    resolveLocalFileHref("\\\\server\\share\\project\\file.txt", "/home/me/project"),
+    "//server/share/project/file.txt",
+  );
+});