@myagentroam/node 0.1.0 → 0.1.2

package/dist/workspace.js

@@ -1,17 +1,270 @@
 import { createHash } from 'node:crypto';
+import { watch } from 'node:fs';
 import { lstat, readdir, readFile, realpath, stat, unlink } from 'node:fs/promises';
 import { homedir, platform as hostPlatform } from 'node:os';
 import { dirname, isAbsolute, posix, relative, resolve, sep, win32 } from 'node:path';
 import { spawn } from 'node:child_process';
+import { minimatch } from 'minimatch';
 const GIT_TIMEOUT_MS = 5_000;
 const GIT_OUTPUT_LIMIT = 512 * 1024;
 const FILE_READ_LIMIT = 512 * 1024;
 const DIRECTORY_PAGE_LIMIT = 200;
 const DIRECTORY_PICKER_LIMIT = 200;
 const SEARCH_RESULT_LIMIT = 200;
-const SEARCH_SCAN_LIMIT = 10_000;
-const FILE_SEARCH_TIMEOUT_MS = 2_000;
+const FILE_INDEX_IDLE_TTL_MS = 60 * 60 * 1_000;
+const FILE_INDEX_ENTRY_LIMIT = 100_000;
+const FILE_INDEX_FALLBACK_POLL_MS = 30_000;
+const DEFAULT_QUICK_OPEN_EXCLUDES = [
+    '**/.git/**',
+    '**/node_modules/**',
+    '**/bower_components/**',
+    '**/.pnpm/**',
+    '**/.yarn/**',
+    '**/.cache/**',
+    '**/.parcel-cache/**',
+    '**/.turbo/**',
+    '**/dist/**',
+    '**/build/**',
+    '**/out/**',
+    '**/coverage/**',
+    '**/.next/**',
+    '**/.nuxt/**',
+    '**/.svelte-kit/**',
+    '**/.angular/**',
+    '**/target/**',
+    '**/.gradle/**',
+    '**/bin/**',
+    '**/obj/**',
+    '**/vendor/**',
+    '**/__pycache__/**',
+    '**/.venv/**',
+    '**/venv/**'
+];
 const REF_PATTERN = /^(?!-)(?!.*\.\.)(?!.*@\{)[A-Za-z0-9][A-Za-z0-9._/-]{0,254}$/;
+/** A per-workspace, process-local index for the Quick Open file picker. */
+export class WorkspaceFileIndex {
+    workspaceRoot;
+    limits;
+    entries = [];
+    truncated = false;
+    root;
+    loading;
+    stale = true;
+    watcher;
+    expiryTimer;
+    fallbackTimer;
+    signature = '';
+    constructor(workspaceRoot, limits = {}) {
+        this.workspaceRoot = workspaceRoot;
+        this.limits = limits;
+    }
+    /** Starts/renews the lightweight index observer without exposing file data. */
+    async observe() {
+        await this.ensureLoaded();
+        this.touch();
+    }
+    dispose() {
+        if (this.expiryTimer !== undefined)
+            clearTimeout(this.expiryTimer);
+        this.expiryTimer = undefined;
+        this.watcher?.close();
+        this.watcher = undefined;
+        if (this.fallbackTimer !== undefined)
+            clearInterval(this.fallbackTimer);
+        this.fallbackTimer = undefined;
+        this.entries = [];
+        this.truncated = false;
+        this.stale = true;
+        this.signature = '';
+    }
+    async search(query, cursor, limit = SEARCH_RESULT_LIMIT) {
+        if (query.trim().length === 0 ||
+            query.length > 256 ||
+            !Number.isSafeInteger(limit) ||
+            limit < 1 ||
+            limit > SEARCH_RESULT_LIMIT)
+            throw new Error('FILE_SEARCH_LIMIT_EXCEEDED');
+        await this.ensureLoaded();
+        this.touch();
+        const after = decodeSearchCursor(cursor, query);
+        const ranked = this.entries
+            .map((entry) => ({ entry, score: fuzzyPathScore(entry.path, query) }))
+            .filter((candidate) => candidate.score !== -1)
+            .sort((left, right) => right.score - left.score || left.entry.path.localeCompare(right.entry.path));
+        const start = after === undefined ? 0 : ranked.findIndex((candidate) => candidate.entry.path === after) + 1;
+        const page = ranked
+            .slice(Math.max(0, start), Math.max(0, start) + limit)
+            .map((candidate) => candidate.entry);
+        const next = ranked[Math.max(0, start) + limit]?.entry.path;
+        return {
+            entries: page,
+            nextCursor: next === undefined ? null : encodeSearchCursor(query, page.at(-1)?.path ?? after ?? ''),
+            truncated: next !== undefined || this.truncated
+        };
+    }
+    async ensureLoaded() {
+        if (!this.stale && this.root !== undefined)
+            return;
+        if (this.loading === undefined) {
+            this.loading = this.rebuild().finally(() => {
+                this.loading = undefined;
+            });
+        }
+        await this.loading;
+    }
+    touch() {
+        if (this.expiryTimer !== undefined)
+            clearTimeout(this.expiryTimer);
+        this.expiryTimer = setTimeout(() => this.dispose(), this.limits.idleTtlMs ?? FILE_INDEX_IDLE_TTL_MS);
+        this.expiryTimer.unref();
+    }
+    async rebuild() {
+        const root = await realpath(this.workspaceRoot);
+        const excludes = [...DEFAULT_QUICK_OPEN_EXCLUDES, ...(await workspaceExcludePatterns(root))];
+        const indexed = [];
+        const entryLimit = this.limits.entryLimit ?? FILE_INDEX_ENTRY_LIMIT;
+        let truncated = false;
+        const directories = ['.'];
+        while (directories.length > 0 && !truncated) {
+            const relativeDirectory = directories.shift();
+            const directory = await resolveWorkspaceEntry(root, relativeDirectory, true).catch(() => undefined);
+            if (directory === undefined)
+                continue;
+            const children = await readdir(directory, { withFileTypes: true }).catch(() => undefined);
+            if (children === undefined)
+                continue;
+            for (const child of children) {
+                const candidatePath = relative(root, resolve(directory, child.name)).split(sep).join('/');
+                if (candidatePath === '.git' ||
+                    candidatePath.startsWith('.git/') ||
+                    isExcluded(candidatePath, excludes))
+                    continue;
+                const resolved = await resolveWorkspaceEntry(root, candidatePath, false).catch(() => undefined);
+                if (resolved === undefined)
+                    continue;
+                const metadata = await lstat(resolved).catch(() => undefined);
+                if (metadata === undefined || (!metadata.isFile() && !metadata.isDirectory()))
+                    continue;
+                const safePath = relative(root, resolved).split(sep).join('/');
+                if (metadata.isDirectory()) {
+                    directories.push(safePath);
+                    continue;
+                }
+                indexed.push({
+                    path: safePath,
+                    name: child.name,
+                    kind: 'FILE',
+                    size: metadata.size,
+                    modifiedAt: metadata.mtimeMs
+                });
+                if (indexed.length >= entryLimit) {
+                    truncated = true;
+                    break;
+                }
+            }
+        }
+        this.root = root;
+        this.entries = indexed;
+        this.truncated = truncated;
+        this.signature = fileIndexSignature(indexed, truncated);
+        this.stale = false;
+        this.watcher?.close();
+        // fs.watch is advisory. Any change safely invalidates the in-memory index;
+        // the next lookup rebuilds it and never trusts stale paths for file reads.
+        try {
+            this.watcher = watch(root, { persistent: false, recursive: true }, () => {
+                this.invalidate();
+            });
+            this.watcher.on('error', () => {
+                this.invalidate();
+                this.watcher?.close();
+                this.watcher = undefined;
+                this.startFallbackPolling();
+            });
+        }
+        catch {
+            // Recursive watching is unavailable on some filesystems. A low-frequency
+            // scan still rebuilds the index, but only emits after its metadata changed.
+            this.watcher = undefined;
+            this.startFallbackPolling();
+        }
+    }
+    startFallbackPolling() {
+        if (this.fallbackTimer !== undefined)
+            return;
+        this.fallbackTimer = setInterval(() => void this.pollFallback(), FILE_INDEX_FALLBACK_POLL_MS);
+        this.fallbackTimer.unref();
+    }
+    async pollFallback() {
+        if (this.loading !== undefined)
+            return;
+        const previous = this.signature;
+        this.stale = true;
+        try {
+            await this.ensureLoaded();
+            if (previous !== this.signature)
+                this.limits.onInvalidated?.();
+        }
+        catch {
+            // Keep the current last-known index. A later poll can recover when the
+            // Workspace becomes readable again.
+            this.stale = false;
+        }
+    }
+    invalidate() {
+        if (this.stale)
+            return;
+        this.stale = true;
+        this.limits.onInvalidated?.();
+    }
+}
+function fileIndexSignature(entries, truncated) {
+    return JSON.stringify({
+        truncated,
+        entries: entries.map((entry) => [entry.path, entry.size, entry.modifiedAt])
+    });
+}
+async function workspaceExcludePatterns(root) {
+    const settingsPath = resolve(root, '.vscode/settings.json');
+    const settings = (await readFile(settingsPath, 'utf8')
+        .then(JSON.parse)
+        .catch(() => undefined));
+    if (typeof settings !== 'object' || settings === null)
+        return [];
+    return ['files.exclude', 'search.exclude'].flatMap((key) => {
+        const value = settings[key];
+        return typeof value === 'object' && value !== null
+            ? Object.entries(value).flatMap(([pattern, enabled]) => (enabled === true ? [pattern] : []))
+            : [];
+    });
+}
+function isExcluded(path, patterns) {
+    return patterns.some((pattern) => minimatch(path, pattern, { dot: true, nocase: hostPlatform() !== 'linux' }) ||
+        minimatch(`${path}/`, pattern, { dot: true, nocase: hostPlatform() !== 'linux' }));
+}
+function fuzzyPathScore(path, query) {
+    const source = path.toLocaleLowerCase();
+    const needle = query.trim().toLocaleLowerCase();
+    let cursor = 0;
+    let score = 0;
+    let previous = -2;
+    for (const character of needle) {
+        const index = source.indexOf(character, cursor);
+        if (index === -1)
+            return -1;
+        score += index === previous + 1 ? 12 : 1;
+        if (index === 0 || '/._-'.includes(source[index - 1] ?? ''))
+            score += 8;
+        previous = index;
+        cursor = index + 1;
+    }
+    const name = path.slice(path.lastIndexOf('/') + 1).toLocaleLowerCase();
+    if (name.includes(needle))
+        score += 40;
+    else if (source.includes(needle))
+        score += 16;
+    return score - path.length / 1_000;
+}
 /**
  * Lists directory names only for the Workspace picker. Browsing begins at the
  * first allowed root when configured, while the Node account home remains a
@@ -51,10 +304,10 @@ export async function listWorkspaceDirectories(requestedPath, allowedRoots, home
         truncated: entries.length > DIRECTORY_PICKER_LIMIT
     };
 }
-export async function listWorkspaceFiles(workspaceRoot, requestedPath = '.', cursor, limit = DIRECTORY_PAGE_LIMIT, options = {}) {
+export async function listWorkspaceFiles(workspaceRoot, requestedPath = '.', cursor, limit = DIRECTORY_PAGE_LIMIT) {
     if (!Number.isSafeInteger(limit) || limit < 1 || limit > DIRECTORY_PAGE_LIMIT)
         throw new Error('DIRECTORY_CURSOR_INVALID');
-    const directory = await resolveWorkspaceEntry(workspaceRoot, requestedPath, true, options);
+    const directory = await resolveWorkspaceEntry(workspaceRoot, requestedPath, true);
     const entries = await readdir(directory, { withFileTypes: true });
     const root = await realpath(workspaceRoot);
     const cursorValue = decodeDirectoryCursor(cursor, requestedPath);
@@ -68,10 +321,18 @@ export async function listWorkspaceFiles(workspaceRoot, requestedPath = '.', cur
     const pageNames = names.slice(start, start + limit);
     const output = [];
     for (const name of pageNames) {
-        const child = await resolveWorkspaceEntry(root, relative(root, resolve(directory, name)), false, options).catch(() => undefined);
+        const child = await resolveWorkspaceEntry(root, relative(root, resolve(directory, name)), false).catch((error) => {
+            if (isSkippableWorkspaceEntryError(error))
+                return undefined;
+            throw error;
+        });
         if (child === undefined)
             continue;
-        const metadata = await lstat(child).catch(() => undefined);
+        const metadata = await lstat(child).catch((error) => {
+            if (error.code === 'ENOENT')
+                return undefined;
+            throw error;
+        });
         if (metadata === undefined || (!metadata.isFile() && !metadata.isDirectory()))
             continue;
         output.push({
@@ -91,8 +352,14 @@ export async function listWorkspaceFiles(workspaceRoot, requestedPath = '.', cur
         truncated: nextName !== undefined
     };
 }
+function isSkippableWorkspaceEntryError(error) {
+    return (error instanceof Error &&
+        (error.message === 'FILE_PATH_ESCAPE' ||
+            error.message === 'FILE_NOT_FOUND' ||
+            error.message === 'FILE_NOT_REGULAR'));
+}
 /** Validates an upload destination without following an existing target symlink. */
-export async function preflightWorkspaceUpload(workspaceRoot, requestedDirectory, name, options = {}) {
+export async function preflightWorkspaceUpload(workspaceRoot, requestedDirectory, name) {
     if (name.length === 0 ||
         name === '.' ||
         name === '..' ||
@@ -103,11 +370,10 @@ export async function preflightWorkspaceUpload(workspaceRoot, requestedDirectory
         return { path: '', absolutePath: '', status: 'INVALID_NAME' };
     }
     const root = await realpath(workspaceRoot);
-    const directory = await resolveWorkspaceEntry(root, requestedDirectory, true, options);
+    const directory = await resolveWorkspaceEntry(root, requestedDirectory, true);
     const absolutePath = resolve(directory, name);
     if (dirname(absolutePath) !== directory)
         throw new Error('FILE_PATH_ESCAPE');
-    assertNotPrivate(absolutePath, options.privateRoots);
     const relativePath = relative(root, absolutePath).split(sep).join('/');
     const metadata = await lstat(absolutePath).catch((error) => {
         if (error.code === 'ENOENT')
@@ -128,7 +394,7 @@ export function workspaceUploadTemporaryName(uploadId) {
 function isWorkspaceUploadTemporaryName(name) {
     return /^\.mar-upload-[0-9a-f-]{36}\.part$/i.test(name);
 }
-export async function readWorkspaceTextFile(workspaceRoot, requestedPath, offset = 0, limit = FILE_READ_LIMIT, options = {}) {
+export async function readWorkspaceTextFile(workspaceRoot, requestedPath, offset = 0, limit = FILE_READ_LIMIT) {
     if (!Number.isSafeInteger(offset) ||
         offset < 0 ||
         !Number.isSafeInteger(limit) ||
@@ -136,7 +402,7 @@ export async function readWorkspaceTextFile(workspaceRoot, requestedPath, offset
         limit > FILE_READ_LIMIT)
         throw new Error('FILE_RANGE_INVALID');
     const root = await realpath(workspaceRoot);
-    const file = await resolveWorkspaceEntry(root, requestedPath, false, options);
+    const file = await resolveWorkspaceEntry(root, requestedPath, false);
     const metadata = await lstat(file);
     if (!metadata.isFile())
         throw new Error('FILE_NOT_REGULAR');
@@ -181,7 +447,7 @@ export async function readWorkspaceTextFile(workspaceRoot, requestedPath, offset
     };
 }
 /** Reads one absolute file only when the resolved target remains within a Node allowed root. */
-export async function readAllowedTextFile(requestedPath, allowedRoots, offset = 0, limit = FILE_READ_LIMIT, options = {}) {
+export async function readAllowedTextFile(requestedPath, allowedRoots, offset = 0, limit = FILE_READ_LIMIT) {
     if (!isAbsolute(requestedPath))
         throw new Error('FILE_PATH_ESCAPE');
     const file = await realpath(requestedPath).catch((error) => {
@@ -192,7 +458,6 @@ export async function readAllowedTextFile(requestedPath, allowedRoots, offset =
     const roots = await Promise.all(allowedRoots.map((root) => realpath(root)));
     if (!isWithinAllowedRoot(file, roots))
         throw new Error('FILE_PATH_ESCAPE');
-    assertNotPrivate(file, options.privateRoots);
     const metadata = await lstat(file);
     if (!metadata.isFile())
         throw new Error('FILE_NOT_REGULAR');
@@ -253,83 +518,16 @@ function isUtf8ContinuationByte(value) {
     return (value & 0b1100_0000) === 0b1000_0000;
 }
 /** Searches file names only, so an exploratory request cannot exfiltrate file contents. */
-export async function searchWorkspaceFiles(workspaceRoot, query, cursor, limit = SEARCH_RESULT_LIMIT, options = {}) {
-    if (query.trim().length === 0 || query.length > 256)
-        throw new Error('FILE_SEARCH_LIMIT_EXCEEDED');
-    if (!Number.isSafeInteger(limit) || limit < 1 || limit > SEARCH_RESULT_LIMIT)
-        throw new Error('FILE_SEARCH_LIMIT_EXCEEDED');
-    const root = await realpath(workspaceRoot);
-    assertNotPrivate(root, options.privateRoots);
-    const after = decodeSearchCursor(cursor, query);
-    const deadline = Date.now() + FILE_SEARCH_TIMEOUT_MS;
-    const results = [];
-    let scanned = 0;
-    let exhausted = true;
-    const directories = ['.'];
-    const normalizedQuery = query.toLocaleLowerCase();
-    while (directories.length > 0) {
-        if (Date.now() > deadline || scanned >= SEARCH_SCAN_LIMIT) {
-            exhausted = false;
-            break;
-        }
-        const directoryPath = directories.shift();
-        const directory = await resolveWorkspaceEntry(root, directoryPath, true, options).catch((error) => {
-            if (error instanceof Error && error.message === 'FILE_NOT_FOUND')
-                return undefined;
-            throw error;
-        });
-        if (directory === undefined)
-            continue;
-        const entries = await readdir(directory, { withFileTypes: true }).catch((error) => {
-            if (error.code === 'ENOENT')
-                return undefined;
-            throw error;
-        });
-        if (entries === undefined)
-            continue;
-        for (const entry of entries.sort((left, right) => left.name.localeCompare(right.name))) {
-            if (entry.name === '.git')
-                continue;
-            scanned += 1;
-            if (scanned > SEARCH_SCAN_LIMIT || Date.now() > deadline) {
-                exhausted = false;
-                break;
-            }
-            const requestPath = relative(root, resolve(directory, entry.name)).split(sep).join('/');
-            const child = await resolveWorkspaceEntry(root, requestPath, false, options).catch(() => undefined);
-            if (child === undefined)
-                continue;
-            const metadata = await lstat(child).catch(() => undefined);
-            if (metadata === undefined || (!metadata.isFile() && !metadata.isDirectory()))
-                continue;
-            const safePath = relative(root, child).split(sep).join('/');
-            if (metadata.isDirectory())
-                directories.push(safePath);
-            if (safePath <= (after ?? '') || !safePath.toLocaleLowerCase().includes(normalizedQuery))
-                continue;
-            results.push({
-                path: safePath,
-                name: entry.name,
-                kind: metadata.isDirectory() ? 'DIRECTORY' : 'FILE',
-                size: metadata.isFile() ? metadata.size : null,
-                modifiedAt: metadata.mtimeMs
-            });
-            if (results.length > limit) {
-                exhausted = false;
-                break;
-            }
-        }
-        if (!exhausted || results.length > limit)
-            break;
+export async function searchWorkspaceFiles(workspaceRoot, query, cursor, limit = SEARCH_RESULT_LIMIT) {
+    const index = new WorkspaceFileIndex(workspaceRoot);
+    try {
+        return await index.search(query, cursor, limit);
+    }
+    finally {
+        index.dispose();
     }
-    results.sort((left, right) => left.path.localeCompare(right.path));
-    const page = results.slice(0, limit);
-    const nextCursor = !exhausted || results.length > limit
-        ? encodeSearchCursor(query, page[page.length - 1]?.path ?? after ?? '')
-        : null;
-    return { entries: page, nextCursor, truncated: nextCursor !== null };
 }
-async function resolveWorkspaceEntry(workspaceRoot, requestedPath, directory, options = {}) {
+async function resolveWorkspaceEntry(workspaceRoot, requestedPath, directory) {
     if (requestedPath.includes('\0') ||
         requestedPath.length === 0 ||
         requestedPath.startsWith('/') ||
@@ -353,20 +551,11 @@ async function resolveWorkspaceEntry(workspaceRoot, requestedPath, directory, op
         pathToCandidate === '..' ||
         pathToCandidate.startsWith(`..${sep}`))
         throw new Error('FILE_PATH_ESCAPE');
-    assertNotPrivate(candidate, options.privateRoots);
     const metadata = await lstat(candidate);
     if (directory ? !metadata.isDirectory() : !metadata.isFile() && !metadata.isDirectory())
         throw new Error(directory ? 'FILE_NOT_DIRECTORY' : 'FILE_NOT_REGULAR');
     return candidate;
 }
-function assertNotPrivate(candidate, privateRoots) {
-    if (privateRoots?.some((privateRoot) => isSameOrDescendant(privateRoot, candidate)))
-        throw new Error('FILE_PATH_ESCAPE');
-}
-function isSameOrDescendant(root, candidate) {
-    const relativePath = relative(root, candidate);
-    return (relativePath === '' || (!relativePath.startsWith('..') && !relativePath.startsWith(`..${sep}`)));
-}
 function encodeDirectoryCursor(path, name) {
     return Buffer.from(JSON.stringify({ path, name })).toString('base64url');
 }
@@ -554,6 +743,7 @@ export async function readCurrentChanges(workspacePath) {
 }
 export async function readCurrentChangeDiff(workspacePath, requestedPath) {
     const path = safeGitWorkspacePath(requestedPath);
+    await assertCurrentChangePathAccessible(workspacePath, path);
     const result = await runGit(workspacePath, [
         'diff',
         '--no-ext-diff',
@@ -579,6 +769,33 @@ export async function readCurrentChangeDiff(workspacePath, requestedPath) {
         ...(after === undefined ? {} : { afterTruncated: after.truncated })
     };
 }
+/** Current Changes must not expose an external link. */
+export async function isWorkspaceChangeVisible(workspacePath, requestedPath) {
+    try {
+        await assertCurrentChangePathAccessible(workspacePath, safeGitWorkspacePath(requestedPath));
+        return true;
+    }
+    catch (error) {
+        if (error instanceof Error &&
+            (error.message === 'FILE_PATH_ESCAPE' ||
+                error.message === 'FILE_NOT_FOUND' ||
+                error.message === 'FILE_NOT_REGULAR'))
+            return false;
+        throw error;
+    }
+}
+async function assertCurrentChangePathAccessible(workspacePath, path) {
+    const root = await realpath(workspacePath);
+    const candidate = resolve(root, path);
+    const metadata = await lstat(candidate).catch((error) => {
+        if (error.code === 'ENOENT')
+            return undefined;
+        throw error;
+    });
+    if (metadata === undefined)
+        return;
+    await resolveWorkspaceEntry(root, path, false);
+}
 async function readWorkingTreeText(workspacePath, path) {
     const root = await realpath(workspacePath);
     let file;
@@ -601,7 +818,7 @@ function diffTextFromBuffer(source, truncated) {
         end -= 1;
     return { binary: false, text: source.subarray(0, end).toString('utf8'), truncated };
 }
-export async function restoreCurrentChange(workspacePath, requestedPath, state, options = {}) {
+export async function restoreCurrentChange(workspacePath, requestedPath, state) {
     const path = safeGitWorkspacePath(requestedPath);
     const pathspec = `:(literal)${path}`;
     if (state === 'UNTRACKED') {
@@ -619,7 +836,6 @@ export async function restoreCurrentChange(workspacePath, requestedPath, state,
             throw new Error('GIT_CHANGE_RESTORE_UNAVAILABLE');
         const root = await realpath(workspacePath);
         const file = resolve(root, path);
-        assertNotPrivate(file, options.privateRoots);
         const metadata = await lstat(file);
         if (!metadata.isFile() || metadata.isSymbolicLink())
             throw new Error('GIT_CHANGE_RESTORE_UNAVAILABLE');