@turns/dev 0.0.8 → 0.0.10

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/git-status.js

@@ -0,0 +1,440 @@
+import { spawn } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import { resolveBrowsePath } from "./file-browsing.js";
+/**
+ * Asking this machine's git what the tree a reader is browsing looks like.
+ *
+ * The browser cannot run git, and the daemon will not hand it a shell, so the
+ * questions worth asking are enumerated here and answered with fixed argument
+ * vectors: a repository path never becomes an option, a pattern, or a shell
+ * fragment. Every invocation is bounded in time and in output, because a work
+ * tree can be arbitrarily large and a browse must not be able to pin a daemon.
+ *
+ * The base revision is picked the way a reviewer would. On the default branch
+ * there is nothing to have diverged from, so the base is `HEAD` and the answer
+ * describes uncommitted work. Anywhere else — a feature branch, or one of the
+ * linked worktrees agents are usually given — the base is the merge point with
+ * the default branch, making the answer the same range a pull request shows.
+ */
+/** A git call has to finish inside a browse, not eventually. */
+export const GIT_COMMAND_TIMEOUT_MS = 10_000;
+/**
+ * Ceilings this daemon answers within, kept in step with the Worker's shared
+ * git module rather than imported from it.
+ *
+ * This package is published on its own and builds with the CLI directory as
+ * its root, so a source file here cannot reach into the Worker's tree: an
+ * import across that boundary compiles under the repo-wide typecheck and then
+ * fails the package build, which is the build that produces what npm ships.
+ * The Worker's `MAX_GIT_STATUS_FILES`, `MAX_GIT_TEXT_BYTES`, and
+ * `MAX_GIT_UNTRACKED_COUNT_BYTES` are the same three numbers; the reader
+ * validates against its own copies, so a daemon that drifted upward would be
+ * trimmed rather than believed.
+ */
+const MAX_GIT_STATUS_FILES = 2_000;
+const MAX_GIT_TEXT_BYTES = 4 * 1024 * 1024;
+const MAX_GIT_UNTRACKED_COUNT_BYTES = 2 * 1024 * 1024;
+/** Local branches are tried before remote-tracking ones: an agent working in a
+ * linked worktree diverged from the checkout beside it, not from the server. */
+const DEFAULT_BRANCH_REFS = [
+    { ref: 'refs/heads/main', label: 'main' },
+    { ref: 'refs/heads/master', label: 'master' },
+    { ref: 'refs/remotes/origin/main', label: 'origin/main' },
+    { ref: 'refs/remotes/origin/master', label: 'origin/master' },
+];
+/**
+ * Run one git command and collect a bounded amount of its output.
+ *
+ * `stderr` is discarded rather than reported: git's diagnostics name paths and
+ * refs on someone else's machine, and every failure here has a useful meaning
+ * of its own — a directory that is not a repository, a file that did not exist
+ * at the base. A non-zero exit is returned rather than thrown so callers can
+ * treat "no such ref" as an answer.
+ */
+function runGit(args, { cwd, limit = MAX_GIT_TEXT_BYTES, timeoutMs = GIT_COMMAND_TIMEOUT_MS, }) {
+    return new Promise((resolve, reject) => {
+        // `--no-pager` and an empty config environment keep a reader's answer from
+        // depending on whatever aliases, pagers, or colour settings this machine has.
+        const child = spawn('git', ['--no-pager', ...args], {
+            cwd,
+            stdio: ['ignore', 'pipe', 'ignore'],
+            env: { ...process.env, GIT_PAGER: 'cat', GIT_OPTIONAL_LOCKS: '0', GIT_TERMINAL_PROMPT: '0' },
+        });
+        const chunks = [];
+        let size = 0;
+        let truncated = false;
+        let stopped = false;
+        let killTimer;
+        const stop = () => {
+            if (stopped)
+                return;
+            stopped = true;
+            child.kill('SIGTERM');
+            killTimer = setTimeout(() => child.kill('SIGKILL'), 100);
+            killTimer.unref?.();
+        };
+        child.stdout.on('data', (chunk) => {
+            if (size >= limit)
+                return;
+            const room = limit - size;
+            chunks.push(chunk.length > room ? chunk.subarray(0, room) : chunk);
+            size += Math.min(room, chunk.length);
+            if (size < limit)
+                return;
+            truncated = true;
+            stop();
+        });
+        child.on('error', (error) => {
+            clearTimeout(timeout);
+            clearTimeout(killTimer);
+            reject(error);
+        });
+        const timeout = setTimeout(() => {
+            truncated = true;
+            stop();
+        }, timeoutMs);
+        timeout.unref?.();
+        child.on('close', (code) => {
+            clearTimeout(timeout);
+            clearTimeout(killTimer);
+            resolve({ code: stopped ? 0 : Number(code ?? 1), stdout: Buffer.concat(chunks).toString('utf8'), truncated });
+        });
+    });
+}
+async function gitLine(args, cwd) {
+    const result = await runGit(args, { cwd, limit: 64 * 1024 });
+    return result.code === 0 ? result.stdout.trim() : '';
+}
+/** Records of a `-z` stream: NUL-terminated, with a trailing empty remainder. */
+function nulRecords(value) {
+    const records = value.split('\u0000');
+    if (records.length && records[records.length - 1] === '')
+        records.pop();
+    return records;
+}
+function absoluteGitDir(root, value) {
+    if (!value)
+        return '';
+    const resolved = path.isAbsolute(value) ? value : path.resolve(root, value);
+    try {
+        return fs.realpathSync(resolved);
+    }
+    catch {
+        return resolved;
+    }
+}
+/**
+ * The work tree holding `directory`, and the revision its changes are measured
+ * from. Returns null when the directory is not inside a git work tree at all,
+ * which is an ordinary answer rather than a failure: most directories are not.
+ */
+export async function readGitBaseRevision(directory) {
+    const rootLine = await gitLine(['rev-parse', '--show-toplevel'], directory);
+    if (!rootLine)
+        return null;
+    let root = rootLine;
+    try {
+        root = fs.realpathSync(rootLine);
+    }
+    catch { }
+    const [gitDir, commonDir, head, branchLine] = await Promise.all([
+        gitLine(['rev-parse', '--git-dir'], root),
+        gitLine(['rev-parse', '--git-common-dir'], root),
+        gitLine(['rev-parse', 'HEAD'], root),
+        gitLine(['rev-parse', '--abbrev-ref', 'HEAD'], root),
+    ]);
+    // A repository with no commits has no HEAD to diff against and nothing a
+    // changes view could show, so it is reported as "not a comparable tree".
+    if (!head)
+        return null;
+    const branch = branchLine === 'HEAD' ? '' : branchLine;
+    const linkedWorkTree = Boolean(gitDir && commonDir && absoluteGitDir(root, gitDir) !== absoluteGitDir(root, commonDir));
+    // `origin/HEAD` is the remote's own statement of its default branch and is
+    // consulted only after the local branches, which is where a linked worktree
+    // actually diverged from.
+    const candidates = [...DEFAULT_BRANCH_REFS];
+    const originHead = await gitLine(['symbolic-ref', '--short', 'refs/remotes/origin/HEAD'], root);
+    if (originHead)
+        candidates.push({ ref: `refs/remotes/${originHead}`, label: originHead });
+    let defaultLabel = '';
+    for (const candidate of candidates) {
+        const resolved = await gitLine(['rev-parse', '--verify', '--quiet', candidate.ref], root);
+        if (!resolved)
+            continue;
+        defaultLabel = candidate.label;
+        break;
+    }
+    const defaultShortName = defaultLabel.replace(/^origin\//u, '');
+    const onDefaultBranch = Boolean(branch) && (branch === defaultLabel || branch === defaultShortName);
+    if (!defaultLabel || onDefaultBranch) {
+        return {
+            root,
+            branch,
+            head,
+            baseLabel: 'HEAD',
+            baseOid: head,
+            onDefaultBranch: true,
+            linkedWorkTree,
+        };
+    }
+    const mergeBase = await gitLine(['merge-base', 'HEAD', defaultLabel], root);
+    // Unrelated histories leave nothing to compare with; fall back to HEAD so the
+    // reader still sees their uncommitted work rather than an error.
+    if (!mergeBase) {
+        return { root, branch, head, baseLabel: 'HEAD', baseOid: head, onDefaultBranch: true, linkedWorkTree };
+    }
+    return { root, branch, head, baseLabel: defaultLabel, baseOid: mergeBase, onDefaultBranch: false, linkedWorkTree };
+}
+/** `add TAB del TAB path`, or `add TAB del TAB` followed by the two paths of a
+ * rename. Binary files report `-` for both counts. */
+function parseNumstat(value) {
+    const records = nulRecords(value);
+    const entries = [];
+    for (let index = 0; index < records.length; index += 1) {
+        const record = records[index];
+        const fields = record.split('\t');
+        if (fields.length < 3)
+            continue;
+        const binary = fields[0] === '-' || fields[1] === '-';
+        const additions = binary ? 0 : Number(fields[0]) || 0;
+        const deletions = binary ? 0 : Number(fields[1]) || 0;
+        let relativePath = fields.slice(2).join('\t');
+        let oldRelativePath = '';
+        if (!relativePath) {
+            oldRelativePath = records[index + 1] || '';
+            relativePath = records[index + 2] || '';
+            index += 2;
+        }
+        if (!relativePath)
+            continue;
+        entries.push({ additions, deletions, binary, relativePath, oldRelativePath });
+    }
+    return entries;
+}
+/** `status NUL path`, or `Rnn NUL old NUL new` for a rename or copy. */
+function parseNameStatus(value) {
+    const records = nulRecords(value);
+    const statuses = new Map();
+    for (let index = 0; index < records.length; index += 1) {
+        const code = records[index] || '';
+        if (!code)
+            continue;
+        if (code.startsWith('R') || code.startsWith('C')) {
+            const target = records[index + 2] || '';
+            if (target)
+                statuses.set(target, code[0]);
+            index += 2;
+            continue;
+        }
+        const target = records[index + 1] || '';
+        if (target)
+            statuses.set(target, code[0]);
+        index += 1;
+    }
+    return statuses;
+}
+function changeStatusFromCode(code, renamed) {
+    if (renamed)
+        return 'renamed';
+    if (code === 'A')
+        return 'added';
+    if (code === 'D')
+        return 'deleted';
+    return 'modified';
+}
+/**
+ * Lines a not-yet-tracked file would add.
+ *
+ * Git has nothing to say about a file it has never seen, and running a diff
+ * per untracked path would multiply process spawns by the size of a build
+ * directory. Counting newlines here is bounded by size and stops at the first
+ * NUL, which is also how the file browser decides a file is not text.
+ */
+function untrackedFileCount(absolutePath) {
+    let stat;
+    try {
+        stat = fs.statSync(absolutePath);
+    }
+    catch {
+        return null;
+    }
+    // Git can name something that is not a regular file — a symlink to a
+    // directory, most often a linked `node_modules`. There is no diff for it and
+    // reporting it as a zero-line change would put a mark against a row nothing
+    // happened in.
+    if (!stat.isFile())
+        return null;
+    if (stat.size > MAX_GIT_UNTRACKED_COUNT_BYTES)
+        return { additions: 0, binary: true };
+    let contents;
+    try {
+        contents = fs.readFileSync(absolutePath);
+    }
+    catch {
+        return { additions: 0, binary: false };
+    }
+    if (contents.includes(0))
+        return { additions: 0, binary: true };
+    if (!contents.length)
+        return { additions: 0, binary: false };
+    let lines = 0;
+    for (const byte of contents)
+        if (byte === 0x0a)
+            lines += 1;
+    // A final line without its newline is still a line the diff would show.
+    return { additions: contents[contents.length - 1] === 0x0a ? lines : lines + 1, binary: false };
+}
+function machinePath(root, relativePath) {
+    return path.posix.join(root.split(path.sep).join('/'), relativePath);
+}
+/**
+ * Every path in one work tree that differs from its base revision.
+ *
+ * Tracked differences come from a single `git diff` against the base, which is
+ * what makes the answer a branch range rather than a working-copy status:
+ * commits made on the branch and edits not yet committed are both in it, in
+ * the same way a pull request shows both. Untracked files are added afterwards
+ * because git will not describe a file it has not been told about.
+ */
+export async function readMachineGitStatus({ requested, workingDirectory = '', allowedDirectories = [], }) {
+    const resolved = resolveBrowsePath(String(requested || ''), { workingDirectory, allowedDirectories });
+    const directory = resolved.stat.isDirectory() ? resolved.path : path.dirname(resolved.path);
+    const revision = await readGitBaseRevision(directory);
+    if (!revision)
+        return null;
+    const [numstat, nameStatus, untracked] = await Promise.all([
+        runGit(['diff', '--numstat', '-z', '--find-renames', '--no-color', revision.baseOid, '--'], { cwd: revision.root }),
+        runGit(['diff', '--name-status', '-z', '--find-renames', '--no-color', revision.baseOid, '--'], {
+            cwd: revision.root,
+        }),
+        runGit(['ls-files', '-z', '--others', '--exclude-standard'], { cwd: revision.root }),
+    ]);
+    const statuses = parseNameStatus(nameStatus.stdout);
+    const files = [];
+    for (const entry of parseNumstat(numstat.stdout)) {
+        const code = statuses.get(entry.relativePath) || 'M';
+        const status = changeStatusFromCode(code, Boolean(entry.oldRelativePath));
+        files.push({
+            path: machinePath(revision.root, entry.relativePath),
+            relativePath: entry.relativePath,
+            status,
+            additions: entry.additions,
+            deletions: entry.deletions,
+            ...(entry.binary ? { binary: true } : {}),
+            ...(entry.oldRelativePath ? { oldRelativePath: entry.oldRelativePath } : {}),
+        });
+        if (files.length >= MAX_GIT_STATUS_FILES)
+            break;
+    }
+    let truncated = numstat.truncated || nameStatus.truncated || untracked.truncated || files.length >= MAX_GIT_STATUS_FILES;
+    for (const relativePath of nulRecords(untracked.stdout)) {
+        if (!relativePath)
+            continue;
+        if (files.length >= MAX_GIT_STATUS_FILES) {
+            truncated = true;
+            break;
+        }
+        const absolute = machinePath(revision.root, relativePath);
+        const counted = untrackedFileCount(absolute);
+        if (!counted)
+            continue;
+        files.push({
+            path: absolute,
+            relativePath,
+            status: 'untracked',
+            additions: counted.additions,
+            deletions: 0,
+            ...(counted.binary ? { binary: true } : {}),
+        });
+    }
+    return {
+        root: revision.root,
+        branch: revision.branch,
+        head: revision.head,
+        baseLabel: revision.baseLabel,
+        baseOid: revision.baseOid,
+        onDefaultBranch: revision.onDefaultBranch,
+        linkedWorkTree: revision.linkedWorkTree,
+        files,
+        additions: files.reduce((total, file) => total + file.additions, 0),
+        deletions: files.reduce((total, file) => total + file.deletions, 0),
+        truncated,
+    };
+}
+/**
+ * One unified patch for the whole work tree, as a review would read it.
+ *
+ * Untracked files are appended as separate `--no-index` patches against
+ * `/dev/null`, which is the same shape git emits for a new file in an ordinary
+ * diff — so the browser's existing unified-diff parser reads both without
+ * knowing which came from where. Only as many as fit under the byte ceiling
+ * are asked for; a patch this long has already stopped being reviewable.
+ */
+export async function readMachineGitPatch({ requested, workingDirectory = '', allowedDirectories = [], }) {
+    const resolved = resolveBrowsePath(String(requested || ''), { workingDirectory, allowedDirectories });
+    const directory = resolved.stat.isDirectory() ? resolved.path : path.dirname(resolved.path);
+    const revision = await readGitBaseRevision(directory);
+    if (!revision)
+        return null;
+    const tracked = await runGit(['diff', '--patch', '--no-color', '--find-renames', '--no-ext-diff', revision.baseOid, '--'], { cwd: revision.root });
+    let patch = tracked.stdout;
+    let truncated = tracked.truncated;
+    if (!truncated) {
+        const untracked = await runGit(['ls-files', '-z', '--others', '--exclude-standard'], { cwd: revision.root });
+        truncated = untracked.truncated;
+        for (const relativePath of nulRecords(untracked.stdout)) {
+            if (!relativePath)
+                continue;
+            if (patch.length >= MAX_GIT_TEXT_BYTES) {
+                truncated = true;
+                break;
+            }
+            // `--no-index` against /dev/null exits 1 on every difference, which is
+            // the normal outcome here rather than a failure.
+            const added = await runGit(['diff', '--no-color', '--no-ext-diff', '--no-index', '--', '/dev/null', relativePath], { cwd: revision.root, limit: Math.max(0, MAX_GIT_TEXT_BYTES - patch.length) });
+            if (added.truncated)
+                truncated = true;
+            if (added.stdout)
+                patch += added.stdout;
+        }
+    }
+    return {
+        root: revision.root,
+        baseLabel: revision.baseLabel,
+        baseOid: revision.baseOid,
+        patch: patch.slice(0, MAX_GIT_TEXT_BYTES),
+        truncated: truncated || patch.length > MAX_GIT_TEXT_BYTES,
+    };
+}
+/**
+ * One file as the base revision holds it, for the viewer's inline diff.
+ *
+ * A file that did not exist at the base is a normal answer — it is what the
+ * viewer needs in order to show the whole file as added — so a missing blob
+ * reports `found: false` rather than raising. Bytes that are not decodable
+ * text are reported as binary instead of being rendered as replacement noise.
+ */
+export async function readMachineGitBaseBlob({ requested, workingDirectory = '', allowedDirectories = [], }) {
+    const resolved = resolveBrowsePath(String(requested || ''), { workingDirectory, allowedDirectories });
+    if (!resolved.stat.isFile())
+        throw new Error(`Not a file: ${resolved.path}`);
+    const revision = await readGitBaseRevision(path.dirname(resolved.path));
+    if (!revision)
+        return null;
+    const relative = path.relative(revision.root, resolved.path).split(path.sep).join('/');
+    if (!relative || relative.startsWith('..'))
+        return null;
+    const shown = await runGit(['show', `${revision.baseOid}:${relative}`], { cwd: revision.root });
+    const found = shown.code === 0;
+    const binary = found && shown.stdout.includes('\u0000');
+    return {
+        path: resolved.path,
+        baseLabel: revision.baseLabel,
+        baseOid: revision.baseOid,
+        found,
+        text: found && !binary ? shown.stdout : '',
+        truncated: found && shown.truncated,
+        binary,
+    };
+}

package/dist/path-resolution.js

@@ -169,6 +169,17 @@ function uploadHeaders(options) {
         ? { 'x-turns-dev-user': options.devUser, 'x-turns-dev-role': 'uploader' }
         : { authorization: `Bearer ${options.token}` };
 }
+/** Keep directory separators readable while escaping characters that would
+ * otherwise change the URL's path, query, or fragment. */
+function fileUploadUrl(baseUrl, machine, absolutePath) {
+    const encoded = absolutePath.split('/').map(encodeURIComponent).join('/');
+    const encodedPath = encoded.startsWith('//')
+        ? `%2F%2F${encoded.slice(2)}`
+        : encoded.startsWith('/')
+            ? encoded.slice(1)
+            : encoded;
+    return new URL(`/api/file/${encodeURIComponent(machine)}/${encodedPath}`, String(baseUrl));
+}
 /**
  * Put bytes in the account's private prefix, under the path they came from.
  *
@@ -177,7 +188,7 @@ function uploadHeaders(options) {
  * the upload is not part of what was stored.
  */
 export async function uploadFileBytes({ baseUrl, options, machine, absolutePath, contentType, modifiedAt, body, fetchImpl = fetch, }) {
-    const url = new URL(`/api/file/${encodeURIComponent(machine)}/${encodeURIComponent(absolutePath)}`, String(baseUrl));
+    const url = fileUploadUrl(baseUrl, machine, absolutePath);
     const response = await fetchImpl(url, {
         method: 'PUT',
         headers: {
@@ -194,7 +205,7 @@ export async function uploadFileBytes({ baseUrl, options, machine, absolutePath,
 }
 /** Stream one on-disk file to R2 without retaining its body in the daemon. */
 export async function uploadFileStream({ baseUrl, options, machine, absolutePath, contentType, bytes, modifiedAt, contentEtag, fetchImpl = fetch, }) {
-    const url = new URL(`/api/file/${encodeURIComponent(machine)}/${encodeURIComponent(absolutePath)}`, String(baseUrl));
+    const url = fileUploadUrl(baseUrl, machine, absolutePath);
     const body = fs.createReadStream(absolutePath);
     try {
         const response = await fetchImpl(url, {

package/dist/queue-worker.js

@@ -8,6 +8,8 @@ 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 { readMachineGitBaseBlob, readMachineGitPatch, readMachineGitStatus } from "./git-status.js";
 import { nativeDescriptorAgentSessionId, nativeDescriptorWorkingDirectory } from "./local-session-sources.js";
 import { compactRuntimeValue } from "./native-record-compaction.js";
 import { createSecretRedactor } from "./secret-redaction.js";
@@ -1069,6 +1071,82 @@ 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)),
+            });
+        }
+    };
+    /**
+     * Answer one git question about a path on this machine.
+     *
+     * Like browsing and searching, this is a property of the filesystem rather
+     * than of a harness, so a stopped session's tree remains readable. A path
+     * that is not inside a work tree answers `ok` with nothing attached: the
+     * browser needs to tell "not a repository" apart from "the machine failed",
+     * and only the first should leave its git column quietly empty.
+     */
+    const handleGitRead = async (message, replyRpc) => {
+        const sessionId = String(message.sessionId || '');
+        const want = message.want === 'diff' ? 'diff' : message.want === 'base' ? 'base' : 'status';
+        try {
+            const input = {
+                requested: String(message.path || ''),
+                workingDirectory: await browseWorkingDirectory(sessionId),
+                allowedDirectories: options.allowedDirectories || [],
+            };
+            const git = want === 'diff'
+                ? await readMachineGitPatch(input).then((patch) => (patch ? { patch } : null))
+                : want === 'base'
+                    ? await readMachineGitBaseBlob(input).then((base) => (base ? { base } : null))
+                    : await readMachineGitStatus(input).then((status) => (status ? { status } : null));
+            replyRpc.notify({
+                type: 'session.git.read.result',
+                requestId: message.requestId,
+                sessionId,
+                ok: true,
+                want,
+                git,
+            });
+        }
+        catch (error) {
+            replyRpc.notify({
+                type: 'session.git.read.result',
+                requestId: message.requestId,
+                sessionId,
+                ok: false,
+                want,
+                error: redactor.redactText(error?.message || String(error)),
+            });
+        }
+    };
     /**
      * Apply one queued browser edit, and report how it went.
      *
@@ -1139,6 +1217,10 @@ 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.git.read.request')
+            void handleGitRead(message, rpc);
         if (message.type === 'session.file.edit.request')
             void handleFileEdit(message, rpc);
     });
@@ -1153,6 +1235,7 @@ export async function watchQueuedPrompts({ rpc, options, machine, getDescriptors
                 type: 'machine.register',
                 machineId: machine,
                 machineHostname: os.hostname(),
+                capabilities: { fileSearch: true, git: true },
                 workerId,
                 workerInstanceId,
                 anchorSessionIds: [...anchors.keys()],

package/package.json

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