@turns/dev 0.0.8 → 0.0.9

package/dist/file-search.js

@@ -0,0 +1,182 @@
+import { spawn } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import { resolveBrowsePath } from "./file-browsing.js";
+/** Kept in step with the Durable Object's recursive search result limit. */
+export const MAX_FILE_SEARCH_RESULTS = 200;
+/** Typeahead must not leave a filesystem walk running after its browser query
+ * has already been superseded. A timed-out walk returns the useful prefix it
+ * found before it was stopped. */
+export const FILE_SEARCH_TIMEOUT_MS = 1_000;
+function isoTime(value) {
+    return Number.isFinite(value) ? new Date(value).toISOString() : '';
+}
+function pathIsInside(directory, candidate) {
+    const relative = path.relative(directory, candidate);
+    return relative !== '' && relative !== '..' && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative);
+}
+function fileSearchEntry(directory, candidate) {
+    if (!pathIsInside(directory, candidate))
+        return null;
+    let link;
+    let stat;
+    try {
+        link = fs.lstatSync(candidate);
+        stat = fs.statSync(candidate);
+    }
+    catch {
+        return null;
+    }
+    const kind = stat.isDirectory() ? 'directory' : stat.isFile() ? 'file' : 'other';
+    const relative = path.relative(directory, candidate).split(path.sep).join('/');
+    return {
+        name: path.basename(candidate),
+        path: candidate,
+        displayName: relative,
+        kind,
+        ...(stat.isFile() ? { size: stat.size } : {}),
+        ...(Number.isFinite(stat.mtimeMs) ? { modifiedAt: isoTime(stat.mtimeMs) } : {}),
+        ...(link.isSymbolicLink() ? { symlink: true } : {}),
+    };
+}
+/**
+ * Run one NUL-delimited path enumerator without involving a shell.
+ *
+ * Queries are matched literally in this process, so punctuation in a browser
+ * query cannot become a glob, regular expression, command option, or shell
+ * fragment. Killing after the result cap also prevents a broad query from
+ * walking a huge tree merely to return entries the client cannot display.
+ */
+function enumeratePaths({ command, args, directory, query, limit, timeoutMs }) {
+    return new Promise((resolve, reject) => {
+        const entries = new Map();
+        const child = spawn(command, args, { stdio: ['ignore', 'pipe', 'ignore'] });
+        let pending = '';
+        let stopped = false;
+        let timedOut = false;
+        let killTimer;
+        const stop = () => {
+            if (stopped)
+                return;
+            stopped = true;
+            child.kill('SIGTERM');
+            killTimer = setTimeout(() => child.kill('SIGKILL'), 100);
+            killTimer.unref?.();
+        };
+        const consider = (rawPath) => {
+            const emitted = String(rawPath || '');
+            if (!emitted)
+                return;
+            const absolute = path.normalize(path.isAbsolute(emitted) ? emitted : path.resolve(directory, emitted));
+            if (!pathIsInside(directory, absolute))
+                return;
+            const relativeParts = path.relative(directory, absolute).split(path.sep);
+            // `rg --files` emits regular files rather than directories. Considering
+            // every prefix reconstructs matching directory observations too, and it
+            // preserves the cache's existing "match anywhere in the relative path"
+            // semantics for descendants of a matching directory.
+            for (let length = 1; length <= relativeParts.length; length += 1) {
+                const relative = relativeParts.slice(0, length).join('/');
+                if (!relative.toLowerCase().includes(query))
+                    continue;
+                const candidate = path.join(directory, ...relativeParts.slice(0, length));
+                if (!entries.has(candidate)) {
+                    const entry = fileSearchEntry(directory, candidate);
+                    if (entry)
+                        entries.set(candidate, entry);
+                }
+                if (entries.size >= limit) {
+                    stop();
+                    break;
+                }
+            }
+        };
+        const consume = (chunk, final = false) => {
+            pending += chunk;
+            let boundary = pending.indexOf('\0');
+            while (boundary !== -1) {
+                consider(pending.slice(0, boundary));
+                pending = pending.slice(boundary + 1);
+                boundary = pending.indexOf('\0');
+            }
+            if (final && pending)
+                consider(pending);
+        };
+        child.stdout.setEncoding('utf8');
+        child.stdout.on('data', (chunk) => consume(chunk));
+        child.on('error', (error) => {
+            clearTimeout(killTimer);
+            reject(error);
+        });
+        const timeout = setTimeout(() => {
+            timedOut = true;
+            stop();
+        }, timeoutMs);
+        timeout.unref?.();
+        child.on('close', (code) => {
+            clearTimeout(timeout);
+            clearTimeout(killTimer);
+            consume('', true);
+            const sorted = [...entries.values()]
+                .sort((left, right) => {
+                if (left.kind === 'directory' && right.kind !== 'directory')
+                    return -1;
+                if (left.kind !== 'directory' && right.kind === 'directory')
+                    return 1;
+                return left.path.localeCompare(right.path);
+            })
+                .slice(0, limit);
+            // Missing tools are tried by the caller. Permission races and partial
+            // walks remain useful if they produced any safe entries.
+            if (code === 0 || stopped || timedOut || sorted.length)
+                resolve(sorted);
+            else
+                reject(new Error(`${command} exited with status ${code}.`));
+        });
+    });
+}
+/**
+ * Find recursive path-name matches on the machine for directory typeahead.
+ *
+ * Ripgrep is preferred because its parallel directory walker is normally the
+ * quickest way to enumerate a project tree. Minimal installations fall back
+ * to POSIX `find`; both emit NUL-delimited names and are filtered literally.
+ */
+export async function searchMachinePaths({ requested, query, workingDirectory = '', allowedDirectories = [], limit = MAX_FILE_SEARCH_RESULTS, timeoutMs = FILE_SEARCH_TIMEOUT_MS, tools = ['rg', 'find'], }) {
+    const needle = String(query || '')
+        .trim()
+        .toLowerCase()
+        .slice(0, 500);
+    const resolved = resolveBrowsePath(String(requested || ''), { workingDirectory, allowedDirectories });
+    if (!resolved.stat.isDirectory())
+        throw new Error(`Not a searchable directory: ${resolved.path}`);
+    if (!needle)
+        return { directory: resolved.path, entries: [] };
+    const boundedLimit = Math.max(1, Math.min(MAX_FILE_SEARCH_RESULTS, Number(limit) || MAX_FILE_SEARCH_RESULTS));
+    const boundedTimeout = Math.max(25, Number(timeoutMs) || FILE_SEARCH_TIMEOUT_MS);
+    let lastError = null;
+    for (const tool of tools) {
+        try {
+            const args = tool === 'rg'
+                ? ['--files', '--hidden', '--no-ignore', '--no-messages', '--null', '--', resolved.path]
+                : tool === 'find'
+                    ? [resolved.path, '-print0']
+                    : [];
+            if (!args.length)
+                continue;
+            const entries = await enumeratePaths({
+                command: tool,
+                args,
+                directory: resolved.path,
+                query: needle,
+                limit: boundedLimit,
+                timeoutMs: boundedTimeout,
+            });
+            return { directory: resolved.path, entries };
+        }
+        catch (error) {
+            lastError = error;
+        }
+    }
+    throw lastError instanceof Error ? lastError : new Error('No filesystem search tool is available.');
+}

package/dist/queue-worker.js

@@ -8,6 +8,7 @@ import { anchorId, connectExistingAgentAnchors, launchAgentAnchor, waitForAgentT
 import { assertAllowedWorkingDirectory, workingDirectoryIsAllowed } from "./directory-policy.js";
 import { browseMachinePath } from "./file-browsing.js";
 import { applyFileEdit } from "./file-edits.js";
+import { searchMachinePaths } from "./file-search.js";
 import { nativeDescriptorAgentSessionId, nativeDescriptorWorkingDirectory } from "./local-session-sources.js";
 import { compactRuntimeValue } from "./native-record-compaction.js";
 import { createSecretRedactor } from "./secret-redaction.js";
@@ -1069,6 +1070,39 @@ export async function watchQueuedPrompts({ rpc, options, machine, getDescriptors
             });
         }
     };
+    /** Refresh recursive path-name matches for directory typeahead.
+     *
+     * Like browsing, this is a machine filesystem operation rather than a
+     * harness operation, so stopped sessions remain searchable. The helper
+     * canonicalizes and allowlists the directory before starting a bounded
+     * ripgrep/find walk; only metadata crosses the control socket. */
+    const handleFileSearch = async (message, replyRpc) => {
+        const sessionId = String(message.sessionId || '');
+        try {
+            const searched = await searchMachinePaths({
+                requested: String(message.directory || ''),
+                query: String(message.query || ''),
+                workingDirectory: await browseWorkingDirectory(sessionId),
+                allowedDirectories: options.allowedDirectories || [],
+            });
+            replyRpc.notify({
+                type: 'session.file.search.result',
+                requestId: message.requestId,
+                sessionId,
+                ok: true,
+                ...searched,
+            });
+        }
+        catch (error) {
+            replyRpc.notify({
+                type: 'session.file.search.result',
+                requestId: message.requestId,
+                sessionId,
+                ok: false,
+                error: redactor.redactText(error?.message || String(error)),
+            });
+        }
+    };
     /**
      * Apply one queued browser edit, and report how it went.
      *
@@ -1139,6 +1173,8 @@ export async function watchQueuedPrompts({ rpc, options, machine, getDescriptors
             void handleInteractionAnswer(message, rpc);
         if (message.type === 'session.file.browse.request')
             void handleFileBrowse(message, rpc);
+        if (message.type === 'session.file.search.request')
+            void handleFileSearch(message, rpc);
         if (message.type === 'session.file.edit.request')
             void handleFileEdit(message, rpc);
     });
@@ -1153,6 +1189,7 @@ export async function watchQueuedPrompts({ rpc, options, machine, getDescriptors
                 type: 'machine.register',
                 machineId: machine,
                 machineHostname: os.hostname(),
+                capabilities: { fileSearch: true },
                 workerId,
                 workerInstanceId,
                 anchorSessionIds: [...anchors.keys()],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@turns/dev",
-  "version": "0.0.8",
+  "version": "0.0.9",
   "description": "Upload local AI agent sessions to turns.dev",
   "license": "MIT",
   "type": "module",