@hyperdrive.bot/paseo-server 0.2.6

package/dist/server/server/uploads/file-attachment-validation.js

@@ -0,0 +1,56 @@
+import { realpathSync } from "node:fs";
+import * as path from "node:path";
+/**
+ * Validate a single staged `file` attachment against the agent's upload staging area.
+ *
+ * Pure (the caller owns the registry and passes the already-looked-up record), so this is
+ * trivially unit-testable against an adversarial table. Checks run in order so the most
+ * specific failure wins:
+ *
+ *   (a) no record for the `fileId`          → `unknown_file_id`
+ *   (b) record belongs to a different agent  → `cross_agent_file_id`
+ *   (c) `realpathSync` throws (file gone)    → `file_missing`
+ *   (d) resolved path escapes the agent dir  → `staging_path_escape`
+ *   (e) otherwise                            → `{ ok: true, path: <realpath> }`
+ *
+ * `realpathSync` follows symlinks, so a symlink whose target lives outside the agent staging
+ * dir is caught by the containment check in (d) — the resolved path can never escape.
+ *
+ * @param args.paseoHome - the daemon's resolved `$PASEO_HOME`
+ * @param args.agentId - the client-supplied agent identifier (`msg.agentId`), the staging scope key
+ * @param args.record - the looked-up registry record for the attachment's `fileId`, or undefined
+ * @returns an accepted resolution carrying the canonical realpath, or a typed rejection
+ */
+export function resolveStagedFileAttachment(args) {
+    const { paseoHome, agentId, record } = args;
+    if (!record) {
+        return { ok: false, error: "unknown_file_id" };
+    }
+    if (record.agentId !== agentId) {
+        return { ok: false, error: "cross_agent_file_id" };
+    }
+    let real;
+    try {
+        real = realpathSync(record.stagedPath);
+    }
+    catch {
+        return { ok: false, error: "file_missing" };
+    }
+    // Compare canonical-to-canonical: realpath BOTH sides. The staging root is realpath'd too so
+    // a symlinked $PASEO_HOME (e.g. macOS /var → /private/var) doesn't make a legitimately-staged
+    // file look like an escape. Containment is still strict — a symlink inside the dir whose
+    // target lives elsewhere resolves outside `realRoot` and is rejected. A root that cannot be
+    // resolved (never created) fails closed as an escape.
+    let realRoot;
+    try {
+        realRoot = realpathSync(path.resolve(paseoHome, "uploads", agentId));
+    }
+    catch {
+        return { ok: false, error: "staging_path_escape" };
+    }
+    if (!real.startsWith(realRoot + path.sep)) {
+        return { ok: false, error: "staging_path_escape" };
+    }
+    return { ok: true, path: real };
+}
+//# sourceMappingURL=file-attachment-validation.js.map

package/dist/server/server/uploads/staging-service.d.ts

@@ -0,0 +1,91 @@
+import { type WriteStream } from "node:fs";
+import type { z } from "zod";
+import { FileBeginMetadataSchema } from "@hyperdrive.bot/paseo-protocol/binary-frames/index";
+import type { FileUploadErrorCode } from "../messages.js";
+export type FileBeginMetadata = z.infer<typeof FileBeginMetadataSchema>;
+/**
+ * Default per-file upload size cap: 100 MB.
+ *
+ * Single source of the cap literal — the `session.ts` begin/chunk handlers consume the
+ * RESOLVED cap via `StagingService.maxFileSizeBytes`, never this constant directly, so the
+ * "100 * 1024 * 1024" literal lives only here.
+ */
+export declare const DEFAULT_MAX_UPLOAD_BYTES: number;
+export interface StagingBeginArgs {
+    agentId: string;
+    uploadId: string;
+    requestId: string;
+    /**
+     * Client-declared original filename, if any. Optional because the Epic-1
+     * `files.upload.begin.request` schema carries no filename field today — when absent the
+     * staged suffix falls back to `upload{ext}`. NEVER participates in the path except through
+     * `sanitizeUploadFilename`.
+     */
+    fileName?: string;
+    metadata: FileBeginMetadata;
+}
+/**
+ * Result of opening a disk-backed staging target for an inbound upload.
+ * On success it hands back a streamed write target (never an in-memory buffer);
+ * on rejection it carries the protocol error code so the caller can abort.
+ */
+export type StagingBeginResult = {
+    accepted: true;
+    writeStream: WriteStream;
+    stagedPath: string;
+    fileId: string;
+} | {
+    accepted: false;
+    error: FileUploadErrorCode;
+};
+export interface StagingService {
+    /**
+     * Resolved per-file upload size cap in bytes (config override or `DEFAULT_MAX_UPLOAD_BYTES`).
+     * Single source for the `session.ts` declared-size early reject and the mid-stream
+     * cumulative-bytes abort — neither re-declares the cap literal.
+     */
+    readonly maxFileSizeBytes: number;
+    /**
+     * Open a streamed write target for an inbound upload.
+     *
+     * Owns sanitization + server-side path construction + containment assertion + stream open
+     * ONLY. It does NOT enforce the size cap — the declared-size early reject lives in the
+     * `session.ts` begin handler so it can refuse before registering the transfer / opening a
+     * stream, and the mid-stream cumulative abort lives in the `session.ts` chunk handler.
+     * `beginUpload` is only reached after the early-reject gate passes.
+     *
+     * @param args - agent/upload/request identity, optional client filename, declared metadata
+     * @returns an accepted result carrying the write stream + staged path + fileId,
+     *          or a rejected result carrying `"write_failed"` (containment / fs failure).
+     */
+    beginUpload(args: StagingBeginArgs): Promise<StagingBeginResult>;
+}
+/**
+ * Map a small set of common mimes to a file extension for the no-filename fallback.
+ * Exhaustive coverage is NOT a goal — the uuid prefix already guarantees uniqueness.
+ */
+export declare function extFromMime(mime: string): string;
+/**
+ * Sanitize a raw client filename into a safe staging suffix. Pure (no I/O), so it is
+ * unit-tested directly against adversarial inputs. Rules applied in order:
+ *
+ *   (a) Unicode-normalize to NFC
+ *   (b) strip path separators `/` and `\`
+ *   (c) strip ASCII control chars `0x00`-`0x1F` and `0x7F` (NUL included)
+ *   (d) strip leading dots so the result is never `.`, `..`, or `.`-prefixed-only
+ *   (e) replace any remaining character not in `[A-Za-z0-9._-]` with `_`
+ *   (f) cap to <= 128 bytes, truncating the base and preserving a trailing extension
+ *   (g) if the result is empty, return the literal `"file"`
+ */
+export declare function sanitizeUploadFilename(rawName: string): string;
+/**
+ * Real staging service (story 2.2 — replaces the 2.1 stub).
+ *
+ * Stages each upload at `${paseoHome}/uploads/${agentId}/${uuid}-${sanitizedFilename}` via a
+ * real `fs.WriteStream` (never buffering). The raw client filename participates in the path
+ * ONLY through `sanitizeUploadFilename`, and a defense-in-depth containment assert guarantees
+ * the resolved path can never escape the agent staging dir. The size cap is resolved ONCE
+ * here and exposed via `maxFileSizeBytes` for the `session.ts` cap seams.
+ */
+export declare function createStagingService(paseoHome: string): StagingService;
+//# sourceMappingURL=staging-service.d.ts.map

package/dist/server/server/uploads/staging-service.js

@@ -0,0 +1,144 @@
+import { createWriteStream } from "node:fs";
+import { mkdir } from "node:fs/promises";
+import { randomUUID } from "node:crypto";
+import * as path from "node:path";
+import { loadPersistedConfig } from "../persisted-config.js";
+/**
+ * Default per-file upload size cap: 100 MB.
+ *
+ * Single source of the cap literal — the `session.ts` begin/chunk handlers consume the
+ * RESOLVED cap via `StagingService.maxFileSizeBytes`, never this constant directly, so the
+ * "100 * 1024 * 1024" literal lives only here.
+ */
+export const DEFAULT_MAX_UPLOAD_BYTES = 100 * 1024 * 1024;
+/** Max staged filename length in bytes (the uuid prefix guarantees uniqueness regardless). */
+const MAX_FILENAME_BYTES = 128;
+const MIME_EXTENSIONS = {
+    "image/png": ".png",
+    "image/jpeg": ".jpg",
+    "application/pdf": ".pdf",
+    "text/plain": ".txt",
+};
+/**
+ * Map a small set of common mimes to a file extension for the no-filename fallback.
+ * Exhaustive coverage is NOT a goal — the uuid prefix already guarantees uniqueness.
+ */
+export function extFromMime(mime) {
+    return MIME_EXTENSIONS[mime] ?? ".bin";
+}
+/**
+ * Truncate a filename to at most `maxBytes` UTF-8 bytes, preserving a trailing extension
+ * where present. The base name is truncated on character boundaries so the result is always
+ * valid UTF-8.
+ */
+function capFilenameBytes(name, maxBytes) {
+    if (Buffer.byteLength(name, "utf8") <= maxBytes) {
+        return name;
+    }
+    const ext = path.extname(name);
+    const extBytes = Buffer.byteLength(ext, "utf8");
+    const base = ext.length > 0 ? name.slice(0, name.length - ext.length) : name;
+    const budget = Math.max(0, maxBytes - extBytes);
+    let truncated = "";
+    let bytes = 0;
+    for (const ch of base) {
+        const chBytes = Buffer.byteLength(ch, "utf8");
+        if (bytes + chBytes > budget) {
+            break;
+        }
+        truncated += ch;
+        bytes += chBytes;
+    }
+    return truncated + ext;
+}
+/**
+ * Sanitize a raw client filename into a safe staging suffix. Pure (no I/O), so it is
+ * unit-tested directly against adversarial inputs. Rules applied in order:
+ *
+ *   (a) Unicode-normalize to NFC
+ *   (b) strip path separators `/` and `\`
+ *   (c) strip ASCII control chars `0x00`-`0x1F` and `0x7F` (NUL included)
+ *   (d) strip leading dots so the result is never `.`, `..`, or `.`-prefixed-only
+ *   (e) replace any remaining character not in `[A-Za-z0-9._-]` with `_`
+ *   (f) cap to <= 128 bytes, truncating the base and preserving a trailing extension
+ *   (g) if the result is empty, return the literal `"file"`
+ */
+export function sanitizeUploadFilename(rawName) {
+    let name = rawName.normalize("NFC");
+    name = name.replace(/[/\\]/g, "");
+    // Strip ASCII control chars 0x00-0x1F and 0x7F (NUL included). Done by code-point
+    // filter (not a regex) so the source carries no control chars and avoids
+    // no-control-regex.
+    name = [...name]
+        .filter((ch) => {
+        const code = ch.codePointAt(0) ?? 0;
+        return !(code <= 0x1f || code === 0x7f);
+    })
+        .join("");
+    name = name.replace(/^\.+/, "");
+    name = name.replace(/[^A-Za-z0-9._-]/g, "_");
+    name = capFilenameBytes(name, MAX_FILENAME_BYTES);
+    if (name.length === 0) {
+        return "file";
+    }
+    return name;
+}
+/**
+ * Resolve the per-file upload size cap from persisted config, falling back to the default.
+ * Reads `daemon.uploads.maxFileSizeBytes` and only honors it when it is a positive integer;
+ * absent / zero / negative values yield `DEFAULT_MAX_UPLOAD_BYTES` (the positive-int guard).
+ */
+function resolveMaxUploadBytes(paseoHome) {
+    const configured = loadPersistedConfig(paseoHome).daemon?.uploads?.maxFileSizeBytes;
+    if (typeof configured === "number" && Number.isInteger(configured) && configured > 0) {
+        return configured;
+    }
+    return DEFAULT_MAX_UPLOAD_BYTES;
+}
+/**
+ * Real staging service (story 2.2 — replaces the 2.1 stub).
+ *
+ * Stages each upload at `${paseoHome}/uploads/${agentId}/${uuid}-${sanitizedFilename}` via a
+ * real `fs.WriteStream` (never buffering). The raw client filename participates in the path
+ * ONLY through `sanitizeUploadFilename`, and a defense-in-depth containment assert guarantees
+ * the resolved path can never escape the agent staging dir. The size cap is resolved ONCE
+ * here and exposed via `maxFileSizeBytes` for the `session.ts` cap seams.
+ */
+export function createStagingService(paseoHome) {
+    const maxFileSizeBytes = resolveMaxUploadBytes(paseoHome);
+    return {
+        maxFileSizeBytes,
+        async beginUpload(args) {
+            const { agentId, fileName, metadata } = args;
+            const suffix = sanitizeUploadFilename(fileName ?? `upload${extFromMime(metadata.mime)}`);
+            const stagedPath = path.join(paseoHome, "uploads", agentId, `${randomUUID()}-${suffix}`);
+            // Containment assert (defense-in-depth): the uuid prefix + sanitization make escape
+            // unreachable in practice, but the assert is acceptance-gating — no stream is opened
+            // unless the resolved path is strictly inside the agent staging dir.
+            const agentDir = path.resolve(paseoHome, "uploads", agentId);
+            if (!path.resolve(stagedPath).startsWith(agentDir + path.sep)) {
+                return { accepted: false, error: "write_failed" };
+            }
+            try {
+                await mkdir(path.dirname(stagedPath), { recursive: true });
+                const writeStream = createWriteStream(stagedPath);
+                // `createWriteStream` opens the fd ASYNCHRONOUSLY. Wait for the file to
+                // actually exist on disk before handing the stream back, otherwise:
+                //   - a chunk written immediately after begin races the open (the staged
+                //     file isn't on disk yet), and
+                //   - an abort's `rm` can run before the open completes, deleting nothing
+                //     and then the late open re-creates the partial AFTER cleanup.
+                // Awaiting `open` makes begin/chunk/abort observe a real on-disk file.
+                await new Promise((resolve, reject) => {
+                    writeStream.once("open", () => resolve());
+                    writeStream.once("error", reject);
+                });
+                return { accepted: true, writeStream, stagedPath, fileId: randomUUID() };
+            }
+            catch {
+                return { accepted: false, error: "write_failed" };
+            }
+        },
+    };
+}
+//# sourceMappingURL=staging-service.js.map

package/dist/server/server/utils/diff-highlighter.d.ts

@@ -0,0 +1,57 @@
+import { type HighlightToken } from "@hyperdrive.bot/paseo-highlight";
+export interface DiffLine {
+    type: "add" | "remove" | "context" | "header";
+    content: string;
+    tokens?: HighlightToken[];
+}
+export interface DiffHunk {
+    oldStart: number;
+    oldCount: number;
+    newStart: number;
+    newCount: number;
+    lines: DiffLine[];
+}
+export interface ParsedDiffFile {
+    path: string;
+    isNew: boolean;
+    isDeleted: boolean;
+    additions: number;
+    deletions: number;
+    hunks: DiffHunk[];
+    status?: "ok" | "too_large" | "binary";
+}
+interface HighlightDiffWithFileContentOptions {
+    oldFileContent?: string | null;
+    newFileContent?: string | null;
+}
+interface ParseAndHighlightDiffOptions {
+    getOldFileContent?: (file: ParsedDiffFile) => Promise<string | null>;
+    getNewFileContent?: (file: ParsedDiffFile) => Promise<string | null>;
+}
+export declare function parseDiff(diffText: string): ParsedDiffFile[];
+/**
+ * Reconstruct the "new" version of a file from diff hunks.
+ * Returns a map of new line numbers to their content.
+ */
+export declare function reconstructNewFile(hunks: DiffHunk[]): Map<number, string>;
+/**
+ * Reconstruct the "old" version of a file from diff hunks.
+ * Returns a map of old line numbers to their content.
+ */
+export declare function reconstructOldFile(hunks: DiffHunk[]): Map<number, string>;
+/**
+ * Apply syntax highlighting to diff hunks using reconstructed file content.
+ * This is the fallback when actual file content is not available.
+ */
+export declare function highlightDiffFromHunks(file: ParsedDiffFile): ParsedDiffFile;
+/**
+ * Apply syntax highlighting to diff hunks using actual file content.
+ * This provides better context for the parser.
+ */
+export declare function highlightDiffWithFileContent(file: ParsedDiffFile, cwd: string, options?: HighlightDiffWithFileContentOptions): Promise<ParsedDiffFile>;
+/**
+ * Parse and highlight a complete diff, using actual file content when available.
+ */
+export declare function parseAndHighlightDiff(diffText: string, cwd: string, options?: ParseAndHighlightDiffOptions): Promise<ParsedDiffFile[]>;
+export type { HighlightToken };
+//# sourceMappingURL=diff-highlighter.d.ts.map

package/dist/server/server/utils/diff-highlighter.js

@@ -0,0 +1,279 @@
+import { readFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import { highlightCode, isLanguageSupported, } from "@hyperdrive.bot/paseo-highlight";
+/**
+ * Parse a unified diff into structured data
+ */
+// Git's default patch headers use paired a/path and b/path prefixes, while
+// diff.noprefix emits plain paths that may legitimately start with a/ or b/.
+function usesDiffPathPrefixes(oldPath, newPath) {
+    return oldPath.startsWith("a/") && newPath.startsWith("b/");
+}
+function extractPathFromMetadata(lines, prefix) {
+    const line = lines.find((candidate) => candidate.startsWith(prefix));
+    if (!line) {
+        return null;
+    }
+    const path = line.slice(prefix.length).replace(/\t.*$/, "").trimEnd();
+    return path === "/dev/null" ? null : path;
+}
+function extractPathFromDiffHeader(lines) {
+    const firstLine = lines[0] ?? "";
+    const prefixedPathMatch = firstLine.match(/^a\/(.+) b\/(.+)$/);
+    if (prefixedPathMatch) {
+        return prefixedPathMatch[2];
+    }
+    const metadataPath = extractPathFromMetadata(lines, "+++ ") ?? extractPathFromMetadata(lines, "--- ");
+    if (metadataPath) {
+        return metadataPath;
+    }
+    const pathMatch = firstLine.match(/^(\S+)\s+(\S+)$/);
+    if (pathMatch) {
+        const [, oldPath, newPath] = pathMatch;
+        const path = newPath === "/dev/null" ? oldPath : newPath;
+        return usesDiffPathPrefixes(oldPath, newPath) ? path.slice(2) : path;
+    }
+    return "unknown";
+}
+function isMetadataLine(line) {
+    return (line.startsWith("index ") ||
+        line.startsWith("--- ") ||
+        line.startsWith("+++ ") ||
+        line.startsWith("new file mode") ||
+        line.startsWith("deleted file mode"));
+}
+function parseHunkHeader(line) {
+    const hunkMatch = line.match(/^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/);
+    if (!hunkMatch)
+        return null;
+    return {
+        oldStart: parseInt(hunkMatch[1], 10),
+        oldCount: parseInt(hunkMatch[2] ?? "1", 10),
+        newStart: parseInt(hunkMatch[3], 10),
+        newCount: parseInt(hunkMatch[4] ?? "1", 10),
+        lines: [{ type: "header", content: line.match(/^(@@ .+? @@)/)?.[1] ?? line }],
+    };
+}
+function parseSectionBody(lines) {
+    const hunks = [];
+    let currentHunk = null;
+    let additions = 0;
+    let deletions = 0;
+    for (let i = 1; i < lines.length; i++) {
+        const line = lines[i];
+        if (isMetadataLine(line))
+            continue;
+        const newHunk = parseHunkHeader(line);
+        if (newHunk) {
+            if (currentHunk)
+                hunks.push(currentHunk);
+            currentHunk = newHunk;
+            continue;
+        }
+        if (!currentHunk)
+            continue;
+        if (line.startsWith("+")) {
+            currentHunk.lines.push({ type: "add", content: line.slice(1) });
+            additions++;
+        }
+        else if (line.startsWith("-")) {
+            currentHunk.lines.push({ type: "remove", content: line.slice(1) });
+            deletions++;
+        }
+        else if (line.startsWith(" ")) {
+            currentHunk.lines.push({ type: "context", content: line.slice(1) });
+        }
+        else if (line.length > 0 && !line.startsWith("\\")) {
+            currentHunk.lines.push({ type: "context", content: line });
+        }
+    }
+    if (currentHunk)
+        hunks.push(currentHunk);
+    return { hunks, additions, deletions };
+}
+export function parseDiff(diffText) {
+    if (!diffText || diffText.trim().length === 0) {
+        return [];
+    }
+    const files = [];
+    const fileSections = diffText.split(/^diff --git /m).filter(Boolean);
+    for (const section of fileSections) {
+        const lines = section.split("\n");
+        const isNew = section.includes("new file mode") || section.includes("--- /dev/null");
+        const isDeleted = section.includes("deleted file mode") || section.includes("+++ /dev/null");
+        const path = extractPathFromDiffHeader(lines);
+        const { hunks, additions, deletions } = parseSectionBody(lines);
+        files.push({ path, isNew, isDeleted, additions, deletions, hunks });
+    }
+    return files;
+}
+/**
+ * Reconstruct the "new" version of a file from diff hunks.
+ * Returns a map of new line numbers to their content.
+ */
+export function reconstructNewFile(hunks) {
+    const lines = new Map();
+    for (const hunk of hunks) {
+        let newLineNum = hunk.newStart;
+        for (const line of hunk.lines) {
+            if (line.type === "header")
+                continue;
+            if (line.type === "add" || line.type === "context") {
+                lines.set(newLineNum, line.content);
+                newLineNum++;
+            }
+        }
+    }
+    return lines;
+}
+/**
+ * Reconstruct the "old" version of a file from diff hunks.
+ * Returns a map of old line numbers to their content.
+ */
+export function reconstructOldFile(hunks) {
+    const lines = new Map();
+    for (const hunk of hunks) {
+        let oldLineNum = hunk.oldStart;
+        for (const line of hunk.lines) {
+            if (line.type === "header")
+                continue;
+            if (line.type === "remove" || line.type === "context") {
+                lines.set(oldLineNum, line.content);
+                oldLineNum++;
+            }
+        }
+    }
+    return lines;
+}
+function buildFileContent(lineMap) {
+    if (lineMap.size === 0)
+        return "";
+    const lineNumbers = Array.from(lineMap.keys()).sort((a, b) => a - b);
+    const minLine = lineNumbers[0];
+    const maxLine = lineNumbers[lineNumbers.length - 1];
+    const lines = [];
+    for (let i = minLine; i <= maxLine; i++) {
+        lines.push(lineMap.get(i) ?? "");
+    }
+    return lines.join("\n");
+}
+function buildTokenLookup(lineMap, highlighted) {
+    const lookup = new Map();
+    if (lineMap.size === 0)
+        return lookup;
+    const lineNumbers = Array.from(lineMap.keys()).sort((a, b) => a - b);
+    const minLine = lineNumbers[0];
+    for (let i = 0; i < highlighted.length; i++) {
+        const lineNum = minLine + i;
+        if (lineMap.has(lineNum)) {
+            lookup.set(lineNum, highlighted[i]);
+        }
+    }
+    return lookup;
+}
+function buildFullFileTokenLookup(fileContent, path) {
+    const lookup = new Map();
+    const highlighted = highlightCode(fileContent, path);
+    for (let i = 0; i < highlighted.length; i++) {
+        lookup.set(i + 1, highlighted[i]);
+    }
+    return lookup;
+}
+function buildReconstructedTokenLookups(file) {
+    const newFileLines = reconstructNewFile(file.hunks);
+    const oldFileLines = reconstructOldFile(file.hunks);
+    const newFileContent = buildFileContent(newFileLines);
+    const oldFileContent = buildFileContent(oldFileLines);
+    const newHighlighted = highlightCode(newFileContent, file.path);
+    const oldHighlighted = highlightCode(oldFileContent, file.path);
+    return {
+        newTokensByLine: buildTokenLookup(newFileLines, newHighlighted),
+        oldTokensByLine: buildTokenLookup(oldFileLines, oldHighlighted),
+    };
+}
+/**
+ * Apply syntax highlighting to diff hunks using reconstructed file content.
+ * This is the fallback when actual file content is not available.
+ */
+export function highlightDiffFromHunks(file) {
+    if (!isLanguageSupported(file.path)) {
+        return file;
+    }
+    const { newTokensByLine, oldTokensByLine } = buildReconstructedTokenLookups(file);
+    return applyTokensToHunks(file, newTokensByLine, oldTokensByLine);
+}
+/**
+ * Apply syntax highlighting to diff hunks using actual file content.
+ * This provides better context for the parser.
+ */
+export async function highlightDiffWithFileContent(file, cwd, options = {}) {
+    if (!isLanguageSupported(file.path)) {
+        return file;
+    }
+    const reconstructedTokens = buildReconstructedTokenLookups(file);
+    let newTokensByLine = reconstructedTokens.newTokensByLine;
+    let oldTokensByLine = reconstructedTokens.oldTokensByLine;
+    if (typeof options.oldFileContent === "string") {
+        oldTokensByLine = buildFullFileTokenLookup(options.oldFileContent, file.path);
+    }
+    if (typeof options.newFileContent === "string") {
+        newTokensByLine = buildFullFileTokenLookup(options.newFileContent, file.path);
+        return applyTokensToHunks(file, newTokensByLine, oldTokensByLine);
+    }
+    const filePath = resolve(cwd, file.path);
+    try {
+        const fileContent = await readFile(filePath, "utf-8");
+        newTokensByLine = buildFullFileTokenLookup(fileContent, file.path);
+    }
+    catch {
+        // If file read fails (deleted file, etc.), fall back to reconstructed new-side tokens.
+    }
+    return applyTokensToHunks(file, newTokensByLine, oldTokensByLine);
+}
+function applyTokensToHunks(file, newTokensByLine, oldTokensByLine) {
+    const highlightedHunks = file.hunks.map((hunk) => {
+        let oldLineNum = hunk.oldStart;
+        let newLineNum = hunk.newStart;
+        const highlightedLines = hunk.lines.map((line) => {
+            if (line.type === "header") {
+                return line;
+            }
+            let tokens;
+            if (line.type === "add") {
+                tokens = newTokensByLine.get(newLineNum);
+                newLineNum++;
+            }
+            else if (line.type === "remove") {
+                tokens = oldTokensByLine.get(oldLineNum);
+                oldLineNum++;
+            }
+            else if (line.type === "context") {
+                // Context lines exist in both - use new file version
+                tokens = newTokensByLine.get(newLineNum);
+                oldLineNum++;
+                newLineNum++;
+            }
+            return tokens ? { ...line, tokens } : line;
+        });
+        return { ...hunk, lines: highlightedLines };
+    });
+    return { ...file, hunks: highlightedHunks };
+}
+/**
+ * Parse and highlight a complete diff, using actual file content when available.
+ */
+export async function parseAndHighlightDiff(diffText, cwd, options = {}) {
+    const files = parseDiff(diffText);
+    const highlightedFiles = await Promise.all(files.map(async (file) => {
+        const [oldFileContent, newFileContent] = await Promise.all([
+            options.getOldFileContent?.(file),
+            options.getNewFileContent?.(file),
+        ]);
+        return highlightDiffWithFileContent(file, cwd, {
+            oldFileContent: oldFileContent ?? undefined,
+            newFileContent: newFileContent ?? undefined,
+        });
+    }));
+    return highlightedFiles;
+}
+//# sourceMappingURL=diff-highlighter.js.map

package/dist/server/server/voice/voice-turn-controller.d.ts

@@ -0,0 +1,38 @@
+import type { Logger } from "pino";
+import type { SpeechToTextProvider } from "../speech/speech-provider.js";
+import type { TurnDetectionProvider } from "../speech/turn-detection-provider.js";
+export interface VoiceTurnControllerCallbacks {
+    onSpeechStarted(): Promise<void>;
+    onSpeechStopped(): Promise<void>;
+    onPartialTranscript(input: {
+        segmentId: string;
+        transcript: string;
+    }): Promise<void>;
+    onFinalTranscript(input: VoiceFinalTranscript): Promise<void>;
+    onError(error: Error): void;
+}
+export interface VoiceTurnController {
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    appendClientChunk(input: {
+        audioBase64: string;
+        format: string;
+    }): Promise<void>;
+}
+interface VoiceFinalTranscript {
+    segmentId: string;
+    transcript: string;
+    language?: string;
+    avgLogprob?: number;
+    isLowConfidence?: boolean;
+    durationMs: number;
+}
+export declare function createVoiceTurnController(params: {
+    logger: Logger;
+    turnDetection: TurnDetectionProvider;
+    stt: SpeechToTextProvider;
+    sttLanguage?: string;
+    callbacks: VoiceTurnControllerCallbacks;
+}): VoiceTurnController;
+export {};
+//# sourceMappingURL=voice-turn-controller.d.ts.map