flashlite 0.0.0-stage → 0.1.0

package/dist/boundedfs.js

@@ -0,0 +1,214 @@
+// Bounded regular-file reads and literal search. No whole-file/whole-line buffering.
+import fs from 'node:fs/promises';
+import { constants } from 'node:fs';
+import { isUtf8 } from 'node:buffer';
+const CHUNK_BYTES = 64 * 1024;
+export const MAX_MATCH_SNIPPET_BYTES = 512;
+export function secretPadding(values) {
+    const padding = Math.max(4, ...values.map((value) => Buffer.byteLength(value)));
+    if (padding > 16384)
+        throw new Error('protected credential exceeds bounded text context limit; use file_info instead');
+    return padding;
+}
+// Redact intersections, including a credential split across page/snippet boundaries.
+export function redactedSlice(bytes, start, end, values) {
+    const ranges = [];
+    for (const value of values) {
+        if (!value)
+            continue;
+        const needle = Buffer.from(value);
+        for (let at = bytes.indexOf(needle); at !== -1; at = bytes.indexOf(needle, at + 1)) {
+            if (at < end && at + needle.length > start)
+                ranges.push([Math.max(at, start), Math.min(at + needle.length, end)]);
+        }
+    }
+    ranges.sort((a, b) => a[0] - b[0]);
+    let at = start, result = '';
+    for (const [left, right] of ranges) {
+        if (right <= at)
+            continue;
+        if (left > at)
+            result += bytes.subarray(at, left).toString('utf8');
+        result += '[REDACTED]';
+        at = right;
+    }
+    return result + bytes.subarray(at, end).toString('utf8');
+}
+const continuation = (byte) => byte !== undefined && (byte & 0xc0) === 0x80;
+async function regularFile(abs, follow, check) {
+    check();
+    // Text reads may resolve an explicitly requested symlink; tree search never does.
+    const target = follow ? await fs.realpath(abs) : abs;
+    const file = await fs.open(target, constants.O_RDONLY | constants.O_NONBLOCK | constants.O_NOFOLLOW);
+    try {
+        check();
+        const stat = await file.stat();
+        if (!stat.isFile())
+            throw new Error('not a regular file — use list_dir or file_info');
+        return { file, stat };
+    }
+    catch (err) {
+        await file.close();
+        throw err;
+    }
+}
+export async function readPage(abs, offset, limit, check, values) {
+    const { file, stat } = await regularFile(abs, true, check);
+    try {
+        if (offset > stat.size)
+            throw new Error(`offset_bytes exceeds file size ${stat.size}; retry offset_bytes: 0 or use file_info`);
+        const padding = secretPadding(values);
+        const base = Math.max(0, offset - padding);
+        const bytes = Buffer.alloc(limit + 2 * padding + 4);
+        let used = 0;
+        while (used < bytes.length) {
+            check();
+            const read = await file.read(bytes, used, bytes.length - used, base + used);
+            check();
+            if (!read.bytesRead)
+                break;
+            used += read.bytesRead;
+        }
+        const buffer = bytes.subarray(0, used);
+        const start = offset - base;
+        if (continuation(buffer[start])) {
+            let previous = start;
+            while (previous > 0 && continuation(buffer[previous]))
+                previous--;
+            throw new Error(`offset_bytes splits a UTF-8 character; retry offset_bytes: ${base + previous}, or use next_offset_bytes from the previous page`);
+        }
+        let end = Math.min(start + limit, used);
+        while (end > start && continuation(buffer[end]))
+            end--;
+        if (end === start && start < used)
+            throw new Error('max_bytes is too small for the next UTF-8 character; retry max_bytes: 4 or larger');
+        const page = buffer.subarray(start, end);
+        if (page.includes(0))
+            throw new Error('binary file — use file_info or copy_path');
+        if (!isUtf8(page))
+            throw new Error('file is not valid UTF-8 text — use file_info or copy_path');
+        check();
+        if ((await file.stat()).size !== stat.size)
+            throw new Error('file changed during read; use file_info then retry offset_bytes: 0');
+        check();
+        const next = offset + page.length;
+        return { offset_bytes: offset, end_offset_bytes: next, total_bytes: stat.size,
+            next_offset_bytes: next < stat.size ? next : null,
+            content: redactedSlice(buffer, start, end, values) };
+    }
+    finally {
+        await file.close();
+    }
+}
+/** Search occurrences, retaining only a chunk, literal overlap and snippet context.
+ * start > 0 deliberately has unknown line numbers; exact byte positions remain valid.
+ */
+export async function searchFile(abs, pattern, start, budget, check, values, onMatch) {
+    const { file, stat } = await regularFile(abs, false, check);
+    try {
+        if (start > stat.size)
+            throw new Error(`start_byte exceeds file size ${stat.size}; retry start_byte: 0`);
+        const padding = secretPadding(values);
+        // A cropped snippet can start/end up to its full width from a match. Keep
+        // credential-length padding beyond BOTH snippet edges, not merely the match.
+        const context = MAX_MATCH_SNIPPET_BYTES + padding;
+        const baseStart = Math.max(0, start - context);
+        let buffer = Buffer.alloc(start - baseStart);
+        if (buffer.length) {
+            check();
+            const prefix = await file.read(buffer, 0, buffer.length, baseStart);
+            check();
+            if (prefix.bytesRead !== buffer.length)
+                throw new Error('file changed during search; use file_info then retry start_byte: 0');
+        }
+        let base = baseStart, readAt = start, scan = start - baseStart, line = start === 0 ? 1 : null;
+        let bytesRead = 0;
+        const chunk = Buffer.alloc(CHUNK_BYTES);
+        while (true) {
+            check();
+            const remaining = budget - bytesRead;
+            const { bytesRead: count } = remaining > 0 ? await file.read(chunk, 0, Math.min(chunk.length, remaining), readAt) : { bytesRead: 0 };
+            check();
+            if (count) {
+                const fresh = chunk.subarray(0, count);
+                bytesRead += count;
+                readAt += count;
+                if (fresh.includes(0))
+                    return { bytesRead, nextByte: null, reason: 'binary file skipped (any earlier matches cover text prefix only)' };
+                buffer = Buffer.concat([buffer, fresh]);
+            }
+            const end = !count || readAt >= stat.size;
+            const searchedEnd = buffer.length;
+            if (end && readAt < stat.size && values.some((value) => value.length > 0)) {
+                // At the scan cap the final snippet may end inside a known credential.
+                // Inspect only bounded suffix context to redact that intersection. These
+                // bytes are NOT searched, emitted, counted as scanned, or consumed by the
+                // continuation offset. Snippet bounds and matching remain at searchedEnd.
+                const suffix = Buffer.alloc(padding);
+                let used = 0;
+                while (used < suffix.length) {
+                    check();
+                    const lookahead = await file.read(suffix, used, suffix.length - used, readAt + used);
+                    check();
+                    if (!lookahead.bytesRead)
+                        break;
+                    used += lookahead.bytesRead;
+                }
+                buffer = Buffer.concat([buffer, suffix.subarray(0, used)]);
+            }
+            // Do not finalize a match until enough suffix exists for a bounded snippet/redaction.
+            const ready = end ? (readAt >= stat.size ? searchedEnd : Math.max(scan, searchedEnd - pattern.length + 1)) :
+                Math.max(scan, searchedEnd - pattern.length - context);
+            while (scan < ready) {
+                check();
+                const found = buffer.indexOf(pattern, scan);
+                const stop = found < 0 || found >= ready ? ready : found;
+                if (line !== null)
+                    for (let i = scan; i < stop; i++)
+                        if (buffer[i] === 10)
+                            line++;
+                scan = stop;
+                if (found < 0 || found >= ready)
+                    break;
+                const previousNL = buffer.lastIndexOf(10, found);
+                const followingNL = buffer.indexOf(10, found + pattern.length);
+                const nextNL = followingNL >= searchedEnd ? -1 : followingNL;
+                let left = Math.max(previousNL + 1, found - 192);
+                let right = Math.min(nextNL < 0 ? searchedEnd : nextNL, left + MAX_MATCH_SNIPPET_BYTES);
+                // UTF-8 boundary adjustment; pattern longer than snippet is intentionally cropped.
+                while (left < found && continuation(buffer[left]))
+                    left++;
+                while (right > left && continuation(buffer[right]))
+                    right--;
+                const snippet = left > previousNL + 1 || nextNL < 0 && readAt < stat.size || right < (nextNL < 0 ? searchedEnd : nextNL) || base + left > start && previousNL < 0;
+                const content = redactedSlice(buffer, left, right, values).trim();
+                if (onMatch({ byte: base + found, line, content, snippet })) {
+                    // The occurrence was NOT accepted. Retrying this byte will not lose it.
+                    return { bytesRead, nextByte: base + found, reason: 'result/output capped' };
+                }
+                // Non-overlapping occurrences; unlike exact edit, grep need not enumerate overlap.
+                const advance = found + pattern.length;
+                if (line !== null)
+                    for (let i = scan; i < advance; i++)
+                        if (buffer[i] === 10)
+                            line++;
+                scan = advance;
+            }
+            if (end) {
+                check();
+                if ((await file.stat()).size !== stat.size)
+                    throw new Error('file changed during search; use file_info then retry start_byte: 0');
+                check();
+                return readAt >= stat.size ? { bytesRead, nextByte: null } :
+                    { bytesRead, nextByte: base + scan, reason: 'scan byte budget reached' };
+            }
+            const drop = Math.max(0, scan - context);
+            buffer = Buffer.from(buffer.subarray(drop));
+            base += drop;
+            scan -= drop;
+        }
+    }
+    finally {
+        await file.close();
+    }
+}

package/dist/chatviewport.js

@@ -0,0 +1,123 @@
+// A bounded display buffer for app-managed scrollback; the composer is not part of it.
+import { stripVTControlCharacters } from 'node:util';
+function cells(c) {
+    if (/\p{Mark}/u.test(c))
+        return 0;
+    const cp = c.codePointAt(0);
+    return cp >= 0x1100 && (cp <= 0x115f || cp >= 0x2e80 && cp <= 0xa4cf ||
+        cp >= 0xac00 && cp <= 0xd7a3 || cp >= 0xf900 && cp <= 0xfaff ||
+        cp >= 0xfe10 && cp <= 0xfe6f || cp >= 0xff00 && cp <= 0xff60 || cp >= 0x1f300) ? 2 : 1;
+}
+export class ChatViewport {
+    lines = [''];
+    anchors = new Set();
+    offset = 0;
+    clear() { this.lines = ['']; this.anchors.clear(); this.offset = 0; }
+    position() {
+        const position = { line: this.lines.length - 1, length: this.lines.at(-1).length };
+        this.anchors.add(position);
+        return position;
+    }
+    release(...positions) {
+        for (const position of positions)
+            this.anchors.delete(position);
+    }
+    trim() {
+        if (this.lines.length <= 10_000)
+            return;
+        const removed = this.lines.length - 10_000;
+        this.lines.splice(0, removed);
+        for (const anchor of this.anchors)
+            anchor.line = Math.max(0, anchor.line - removed);
+    }
+    replace(start, end, text, columns) {
+        const before = this.offset ? this.rows(columns).length : 0;
+        const oldEndLine = end.line;
+        const oldEndLength = end.length;
+        const prefix = this.lines[start.line]?.slice(0, start.length) ?? '';
+        const suffix = this.lines[end.line]?.slice(end.length) ?? '';
+        const inserted = (prefix + text).split('\n');
+        const newEndLine = start.line + inserted.length - 1;
+        const newEndLength = inserted.at(-1).length;
+        inserted[inserted.length - 1] += suffix;
+        this.lines.splice(start.line, oldEndLine - start.line + 1, ...inserted);
+        const delta = newEndLine - oldEndLine;
+        for (const anchor of this.anchors) {
+            if (anchor === start)
+                continue;
+            if (anchor === end) {
+                anchor.line = newEndLine;
+                anchor.length = newEndLength;
+            }
+            else if (anchor.line > oldEndLine)
+                anchor.line += delta;
+            else if (anchor.line === oldEndLine && anchor.length >= oldEndLength) {
+                anchor.line = newEndLine;
+                anchor.length = newEndLength + anchor.length - oldEndLength;
+            }
+        }
+        this.trim();
+        if (this.offset)
+            this.offset = Math.max(0, this.offset + this.rows(columns).length - before);
+    }
+    remove(start, end) {
+        this.replace(start, end, '', 80);
+        this.offset = 0;
+    }
+    append(text, columns) {
+        const before = this.offset ? this.rows(columns).length : 0;
+        for (const part of text.split(/(\n|\r\x1b\[K)/)) {
+            if (part === '\n')
+                this.lines.push('');
+            else if (part === '\r\x1b[K')
+                this.lines[this.lines.length - 1] = '';
+            else
+                this.lines[this.lines.length - 1] += part;
+        }
+        this.trim();
+        if (this.offset)
+            this.offset = Math.max(0, this.offset + this.rows(columns).length - before);
+    }
+    rows(columns) {
+        const rows = [];
+        columns = Math.max(1, columns);
+        let style = '';
+        for (const line of this.lines) {
+            let row = style, used = 0;
+            for (const token of line.match(/\x1b\[[0-?]*[ -/]*[@-~]|\x1b.|[^\x1b]/gu) ?? []) {
+                if (token.startsWith('\x1b')) {
+                    if (/^\x1b\[[\d;]*m$/.test(token)) {
+                        row += token;
+                        style = /^\x1b\[(0)?m$/.test(token) ? '' : style + token;
+                    }
+                    continue;
+                }
+                if (token === '\r' || token < ' ')
+                    continue;
+                if (used + cells(token) > columns) {
+                    rows.push(row + (style ? '\x1b[0m' : ''));
+                    row = style;
+                    used = 0;
+                }
+                row += token;
+                used += cells(token);
+            }
+            rows.push(row + (style ? '\x1b[0m' : ''));
+        }
+        return rows;
+    }
+    scroll(delta, columns, height) {
+        this.offset = Math.max(0, Math.min(Math.max(0, this.rows(columns).length - height), this.offset + delta));
+    }
+    visible(columns, height) {
+        const rows = this.rows(columns);
+        const end = Math.max(height, rows.length - this.offset);
+        this.offset = Math.min(this.offset, Math.max(0, rows.length - height));
+        return rows.slice(Math.max(0, end - height), end);
+    }
+    caret(columns, height) {
+        const rows = this.rows(columns);
+        const last = stripVTControlCharacters(rows.at(-1) ?? '');
+        return { row: Math.min(height, rows.length), column: Math.min(columns + 1, [...last].reduce((sum, c) => sum + cells(c), 0) + 1) };
+    }
+}

package/dist/checkpoint.js

@@ -0,0 +1,100 @@
+// Git-style undo for file-tool mutations. Before a mutating file tool runs, the target
+// path's original bytes (or absence) are captured; `/undo` restores the most recent turn's
+// captured files. run_command side effects are never captured (arbitrary shell is not
+// reversible this way). State is in-memory per REPL session — undo works until you exit.
+import fs from 'node:fs';
+import path from 'node:path';
+const MAX_CHECKPOINTS = 32;
+const MAX_FILE_BYTES = 8 * 1024 * 1024; // refuse to buffer very large files
+/** Mutating file tools whose target(s) we snapshot before they run. */
+const CAPTURE_PATHS = {
+    write_file: (args) => [asPath(args.path)],
+    edit_file: (args) => [asPath(args.path)],
+    make_dir: (args) => [asPath(args.path)],
+    remove_path: (args) => [asPath(args.path)],
+    copy_path: (args) => [asPath(args.destination)],
+    move_path: (args) => [asPath(args.source), asPath(args.destination)],
+};
+function asPath(value) {
+    return typeof value === 'string' ? value : '';
+}
+export class UndoStack {
+    turn = null;
+    stack = [];
+    /** Start a fresh capture set for a new turn. */
+    beginTurn() {
+        this.turn = null;
+    }
+    /** Capture a tool's target paths before execution (absolute, resolved against cwd). */
+    capture(cwd, name, args) {
+        const extract = CAPTURE_PATHS[name];
+        if (!extract)
+            return;
+        const paths = extract(args).filter(Boolean).map((p) => path.resolve(cwd, p));
+        if (paths.length === 0)
+            return;
+        if (!this.turn)
+            this.turn = { files: [], count: 0 };
+        for (const target of paths) {
+            if (this.turn.files.some((f) => f.path === target))
+                continue; // already captured this turn
+            let stat;
+            try {
+                stat = fs.lstatSync(target);
+            }
+            catch { /* absent */ }
+            const existed = !!stat && (stat.isFile() || stat.isSymbolicLink());
+            const entry = { path: target, existed };
+            if (existed && stat.size <= MAX_FILE_BYTES) {
+                try {
+                    entry.content = fs.readFileSync(target);
+                }
+                catch {
+                    entry.content = undefined;
+                }
+            }
+            this.turn.files.push(entry);
+            this.turn.count++;
+        }
+    }
+    /** Seal the turn's captures; a turn with no file mutations records nothing. */
+    endTurn() {
+        if (this.turn && this.turn.files.length > 0) {
+            this.stack.push(this.turn);
+            if (this.stack.length > MAX_CHECKPOINTS)
+                this.stack.shift();
+        }
+        this.turn = null;
+    }
+    hasUndo() {
+        return this.stack.length > 0;
+    }
+    /** Restore the most recent turn's captured files; returns human-readable summary lines. */
+    undo(cwd) {
+        const checkpoint = this.stack.pop();
+        if (!checkpoint || checkpoint.files.length === 0)
+            return ['nothing to undo'];
+        const lines = [];
+        for (const file of [...checkpoint.files].reverse()) {
+            const rel = path.relative(cwd, file.path) || file.path;
+            try {
+                if (file.existed && file.content !== undefined) {
+                    fs.mkdirSync(path.dirname(file.path), { recursive: true });
+                    fs.writeFileSync(file.path, file.content);
+                    lines.push(`restored ${rel}`);
+                }
+                else if (!file.existed) {
+                    fs.rmSync(file.path, { force: true });
+                    lines.push(`removed ${rel}`);
+                }
+                else {
+                    lines.push(`kept ${rel} (original not captured — file too large)`);
+                }
+            }
+            catch (err) {
+                lines.push(`could not restore ${rel}: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
+        return lines;
+    }
+}