@datename/fastcode-termux 0.1.6 → 0.1.8-beta.0

package/dist/agent/tools/paths.d.ts

@@ -0,0 +1,7 @@
+import type { ToolCall } from "./types.js";
+export declare function allowedRoots(cwd: string): string[];
+export declare function resolveSharedDir(cwd: string, entry: string): string;
+export declare function isInsideAny(child: string, roots: string[]): boolean;
+export declare function resolvePath(cwd: string, call: ToolCall, fallback?: string): string;
+export declare function sandboxPath(cwd: string, raw: string): string;
+export declare function realpathOf(input: string): string | undefined;

package/dist/agent/tools/paths.js

@@ -0,0 +1,84 @@
+import { existsSync, realpathSync } from "node:fs";
+import { basename, delimiter, dirname, isAbsolute, join, relative, resolve } from "node:path";
+import { detectPlatform, safeHome } from "../../lib/platform.js";
+import { loadConfig } from "../../config/store.js";
+export function allowedRoots(cwd) {
+    const roots = [resolve(cwd)];
+    const configured = (process.env["FASTCODE_ALLOW_PATHS"] ?? "")
+        .split(delimiter)
+        .map((entry) => entry.trim())
+        .filter(Boolean);
+    for (const entry of configured)
+        roots.push(resolve(entry));
+    const sharedDirs = loadConfig().sharedDirs;
+    if (Array.isArray(sharedDirs)) {
+        for (const entry of sharedDirs) {
+            if (typeof entry !== "string" || !entry.trim())
+                continue;
+            roots.push(resolveSharedDir(cwd, entry.trim()));
+        }
+    }
+    if (detectPlatform() === "termux" && !isDisabled(process.env["FASTCODE_ALLOW_SHARED_STORAGE"])) {
+        const home = process.env["HOME"];
+        if (home) {
+            const shared = join(home, "storage", "shared");
+            if (existsSync(shared))
+                roots.push(shared);
+        }
+    }
+    return roots;
+}
+export function resolveSharedDir(cwd, entry) {
+    const expanded = entry === "~" || entry.startsWith("~/") || entry.startsWith("~\\")
+        ? join(safeHome(), entry.slice(1))
+        : entry;
+    return isAbsolute(expanded) ? resolve(expanded) : resolve(cwd, expanded);
+}
+function isDisabled(value) {
+    if (value === undefined)
+        return false;
+    return ["0", "false", "no", "off"].includes(value.trim().toLowerCase());
+}
+export function isInsideAny(child, roots) {
+    return roots.some((root) => {
+        const rel = relative(root, child);
+        return rel === "" || (!rel.startsWith("..") && !isAbsolute(rel));
+    });
+}
+export function resolvePath(cwd, call, fallback = "") {
+    const raw = typeof call.path === "string" ? call.path : fallback;
+    return sandboxPath(cwd, raw);
+}
+export function sandboxPath(cwd, raw) {
+    const target = resolve(cwd, raw);
+    const roots = allowedRoots(cwd);
+    const realRoots = roots.map((root) => realpathOf(root)).filter(Boolean);
+    const realTarget = realpathOf(target);
+    if (realTarget) {
+        if (isInsideAny(realTarget, realRoots))
+            return target;
+        throw new Error("path outside sandbox: " + raw);
+    }
+    if (isInsideAny(target, roots))
+        return target;
+    throw new Error("path outside sandbox: " + raw);
+}
+export function realpathOf(input) {
+    let current = resolve(input);
+    const missing = [];
+    for (;;) {
+        if (existsSync(current)) {
+            try {
+                return join(realpathSync(current), ...missing.slice().reverse());
+            }
+            catch {
+                return undefined;
+            }
+        }
+        const parent = dirname(current);
+        if (parent === current)
+            return undefined;
+        missing.push(basename(current));
+        current = parent;
+    }
+}

package/dist/agent/tools/pwd.d.ts

@@ -0,0 +1,2 @@
+import type { Tool } from "./types.js";
+export declare const pwdTool: Tool;

package/dist/agent/tools/pwd.js

@@ -0,0 +1,10 @@
+export const pwdTool = {
+    name: "pwd",
+    stateScope: "call",
+    prepare() {
+        return { ok: true };
+    },
+    async execute(_call, ctx) {
+        return { ok: true, output: ctx.cwd };
+    },
+};

package/dist/agent/tools/read_file.d.ts

@@ -0,0 +1,2 @@
+import type { Tool } from "./types.js";
+export declare const readFileTool: Tool;

package/dist/agent/tools/read_file.js

@@ -0,0 +1,81 @@
+import { readFileRange, readTextFileResult } from "./readers.js";
+import { resolvePath } from "./paths.js";
+import { clampInt, invalid, optionalNumber, preparePath, requiredString } from "./validate.js";
+const MAX_READ_LINES = 2000;
+export const readFileTool = {
+    name: "read_file",
+    stateScope: "call",
+    revalidate: ["sandboxRoots"],
+    prepare(call, ctx) {
+        let path;
+        try {
+            path = requiredString(call, "path");
+            const offset = optionalNumber(call, "offset");
+            const limit = optionalNumber(call, "limit");
+            if (offset !== undefined && offset < 1)
+                return invalid("offset must be >= 1");
+            if (limit !== undefined && limit < 1)
+                return invalid("limit must be >= 1");
+        }
+        catch (err) {
+            return invalid(err.message);
+        }
+        return preparePath(ctx.cwd, path);
+    },
+    async execute(call, ctx) {
+        const file = resolvePath(ctx.cwd, call);
+        const offset = optionalNumber(call, "offset");
+        const limit = optionalNumber(call, "limit");
+        if (offset === undefined && limit === undefined) {
+            const result = await readTextFileResult(file);
+            const output = result.truncated
+                ? `${result.text}\n[... truncated at ${result.returnedBytes} of ${result.totalBytes} bytes; use offset/limit, grep, or a narrower file ...]`
+                : result.text;
+            return {
+                ok: true,
+                output,
+                truncated: result.truncated,
+                totalLines: result.totalLines,
+                returnedLines: result.returnedLines,
+                totalBytes: result.totalBytes,
+                returnedBytes: result.returnedBytes,
+            };
+        }
+        const start = clampInt(offset, 1, 1, 1_000_000);
+        const count = clampInt(limit, MAX_READ_LINES, 1, MAX_READ_LINES);
+        const result = await readFileRange(file, start, count, { signal: ctx.signal });
+        if (result.binary) {
+            return {
+                ok: true,
+                output: result.text,
+                truncated: false,
+                totalLines: 0,
+                returnedLines: 0,
+                totalBytes: result.totalBytes,
+                returnedBytes: 0,
+            };
+        }
+        if (result.returnedLines === 0 && start > result.totalLines) {
+            return {
+                ok: false,
+                output: `offset ${start} is beyond the end of ${file} (${result.totalLines} lines)`,
+                code: "NOT_FOUND",
+                hint: "Use a smaller offset or read without offset.",
+                totalLines: result.totalLines,
+                returnedLines: 0,
+            };
+        }
+        const end = start + result.returnedLines - 1;
+        const header = `[lines ${start}-${end} of ${result.totalLines}${result.scannedAll ? "" : "+"}]\n`;
+        return {
+            ok: true,
+            output: header + result.text,
+            truncated: result.truncated,
+            hint: result.scannedAll ? undefined : "totalLines is a lower bound; the file scan hit FASTCODE_READ_SCAN_MAX_BYTES.",
+            totalLines: result.totalLines,
+            returnedLines: result.returnedLines,
+            totalBytes: result.totalBytes,
+            returnedBytes: result.returnedBytes,
+        };
+    },
+};

package/dist/agent/tools/read_many.d.ts

@@ -0,0 +1,2 @@
+import type { Tool } from "./types.js";
+export declare const readManyTool: Tool;

package/dist/agent/tools/read_many.js

@@ -0,0 +1,43 @@
+import { readManyResult } from "./readers.js";
+import { invalid, optionalNumber, preparePath, stringArray } from "./validate.js";
+export const readManyTool = {
+    name: "read_many",
+    stateScope: "call",
+    revalidate: ["sandboxRoots"],
+    prepare(call, ctx) {
+        let paths;
+        try {
+            paths = stringArray(call, "paths");
+            if (paths.length === 0)
+                return invalid("paths must contain at least one path");
+            const maxBytes = optionalNumber(call, "maxBytes");
+            if (maxBytes !== undefined && maxBytes < 1)
+                return invalid("maxBytes must be >= 1");
+        }
+        catch (err) {
+            return invalid(err.message);
+        }
+        for (const path of paths) {
+            const checked = preparePath(ctx.cwd, path);
+            if (!checked.ok)
+                return checked;
+        }
+        return { ok: true };
+    },
+    async execute(call, ctx) {
+        const paths = stringArray(call, "paths");
+        const requested = optionalNumber(call, "maxBytes");
+        const maxBytes = requested === undefined ? undefined : Math.max(1, Math.floor(requested));
+        const result = await readManyResult(ctx.cwd, paths, maxBytes);
+        return {
+            ok: true,
+            output: result.text,
+            truncated: result.truncated,
+            totalBytes: result.totalBytes,
+            returnedBytes: result.returnedBytes,
+            filesRead: result.filesRead,
+            filesSkipped: result.filesSkipped,
+            hint: result.filesSkipped > 0 ? `${result.filesSkipped} file(s) skipped by the read_many byte budget.` : undefined,
+        };
+    },
+};

package/dist/agent/tools/readers.d.ts

@@ -0,0 +1,58 @@
+export interface ReadManyResult {
+    text: string;
+    truncated: boolean;
+    totalBytes: number;
+    returnedBytes: number;
+    filesRead: number;
+    filesSkipped: number;
+}
+export declare function readManyResult(cwd: string, paths: string[], maxBytes?: number): Promise<ReadManyResult>;
+export declare function readMany(cwd: string, paths: string[]): Promise<string>;
+export declare function listFiles(sandbox: string, root: string, maxDepth: number, detail: boolean): Promise<string>;
+export declare function formatSize(bytes: number): string;
+export interface GrepOptions {
+    pattern: string;
+    flags?: string;
+    glob?: string;
+    context?: number;
+    maxResults?: number;
+    maxDepth?: number;
+    signal?: AbortSignal;
+}
+export interface GrepResult {
+    text: string;
+    truncated: boolean;
+    matchCount: number;
+    filesScanned: number;
+}
+export declare function grepFiles(sandbox: string, root: string, options: GrepOptions): Promise<GrepResult>;
+export interface ReadTextResult {
+    text: string;
+    truncated: boolean;
+    totalLines?: number;
+    returnedLines: number;
+    totalBytes: number;
+    returnedBytes: number;
+    binary: boolean;
+}
+export declare function readTextFileResult(file: string, limit?: number): Promise<ReadTextResult>;
+export interface ReadRangeResult {
+    text: string;
+    truncated: boolean;
+    totalLines: number;
+    returnedLines: number;
+    totalBytes: number;
+    returnedBytes: number;
+    scannedAll: boolean;
+    binary: boolean;
+}
+export declare function readFileRange(file: string, offset: number, limit: number, options?: {
+    maxBytes?: number;
+    scanMaxBytes?: number;
+    signal?: AbortSignal;
+}): Promise<ReadRangeResult>;
+export declare function readTextFile(file: string, limit?: number): Promise<string>;
+export declare function readMaxBytes(): number;
+export declare function grepMaxBytes(): number;
+export declare function readScanMaxBytes(): number;
+export declare function readManyMaxBytes(): number;