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

package/src/agent/tools/move_path.ts

@@ -0,0 +1,83 @@
+import { cp, mkdir, rename, rm } from "node:fs/promises";
+import { lstatSync } from "node:fs";
+import { dirname } from "node:path";
+import { sandboxPath } from "./paths.js";
+import type { Tool } from "./types.js";
+import { invalid, preparePath, requiredString } from "./validate.js";
+
+function exists(path: string): boolean {
+    try {
+        lstatSync(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+
+export interface MoveOps {
+    rename: typeof rename;
+    cp: typeof cp;
+    rm: typeof rm;
+}
+
+export async function moveWithFallback(from: string, to: string, ops: MoveOps = { rename, cp, rm }): Promise<"rename" | "copy"> {
+    try {
+        await ops.rename(from, to);
+        return "rename";
+    }
+    catch (err: any) {
+        if (err?.code !== "EXDEV")
+            throw err;
+        await ops.cp(from, to, { recursive: true, force: false, errorOnExist: true });
+        try {
+            await ops.rm(from, { recursive: true, force: false });
+        }
+        catch (cleanup: any) {
+            throw Object.assign(new Error(`copied ${from} to ${to}, but could not remove the source: ${cleanup?.message ?? String(cleanup)}`), {
+                code: "UNKNOWN",
+            });
+        }
+        return "copy";
+    }
+}
+
+export const movePathTool: Tool = {
+    name: "move_path",
+    requiresTrust: true,
+    stateScope: "turn",
+    revalidate: ["trust", "sandboxRoots"],
+    prepare(call, ctx) {
+        try {
+            const from = requiredString(call, "from");
+            const to = requiredString(call, "to");
+            const checkedFrom = preparePath(ctx.cwd, from);
+            if (!checkedFrom.ok)
+                return checkedFrom;
+            const checkedTo = preparePath(ctx.cwd, to);
+            if (!checkedTo.ok)
+                return checkedTo;
+            if (exists(to))
+                return invalid(`move target exists: ${to}`, "EEXIST", "Choose a target that does not exist.");
+            return { ok: true };
+        }
+        catch (err: any) {
+            return invalid(err.message);
+        }
+    },
+    async execute(call, ctx) {
+        const from = sandboxPath(ctx.cwd, requiredString(call, "from"));
+        const to = sandboxPath(ctx.cwd, requiredString(call, "to"));
+        if (exists(to))
+            return { ok: false, output: `move target exists: ${to}`, code: "EEXIST", hint: "Choose a target that does not exist." };
+        await mkdir(dirname(to), { recursive: true });
+        const method = await moveWithFallback(from, to);
+        return {
+            ok: true,
+            output: method === "copy"
+                ? `moved ${from} to ${to} (cross-device copy + remove)`
+                : `moved ${from} to ${to}`,
+            sideEffects: { removed: [from], touched: [to] },
+        };
+    },
+};

package/src/agent/tools/paths.ts

@@ -0,0 +1,92 @@
+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";
+import type { ToolCall } from "./types.js";
+
+export function allowedRoots(cwd: string): string[] {
+    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: string, entry: string): string {
+    const expanded = entry === "~" || entry.startsWith("~/") || entry.startsWith("~\\")
+        ? join(safeHome(), entry.slice(1))
+        : entry;
+    return isAbsolute(expanded) ? resolve(expanded) : resolve(cwd, expanded);
+}
+
+function isDisabled(value: string | undefined): boolean {
+    if (value === undefined)
+        return false;
+    return ["0", "false", "no", "off"].includes(value.trim().toLowerCase());
+}
+
+export function isInsideAny(child: string, roots: string[]): boolean {
+    return roots.some((root) => {
+        const rel = relative(root, child);
+        return rel === "" || (!rel.startsWith("..") && !isAbsolute(rel));
+    });
+}
+
+export function resolvePath(cwd: string, call: ToolCall, fallback = ""): string {
+    const raw = typeof call.path === "string" ? call.path : fallback;
+    return sandboxPath(cwd, raw);
+}
+
+export function sandboxPath(cwd: string, raw: string): string {
+    const target = resolve(cwd, raw);
+    const roots = allowedRoots(cwd);
+    const realRoots = roots.map((root) => realpathOf(root)).filter(Boolean) as string[];
+    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: string): string | undefined {
+    let current = resolve(input);
+    const missing: string[] = [];
+    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/src/agent/tools/pwd.ts

@@ -0,0 +1,12 @@
+import type { Tool } from "./types.js";
+
+export const pwdTool: Tool = {
+    name: "pwd",
+    stateScope: "call",
+    prepare() {
+        return { ok: true };
+    },
+    async execute(_call, ctx) {
+        return { ok: true, output: ctx.cwd };
+    },
+};

package/src/agent/tools/read_file.ts

@@ -0,0 +1,84 @@
+import { readFileRange, readTextFileResult } from "./readers.js";
+import { resolvePath } from "./paths.js";
+import type { Tool } from "./types.js";
+import { clampInt, invalid, optionalNumber, preparePath, requiredString } from "./validate.js";
+
+const MAX_READ_LINES = 2000;
+
+export const readFileTool: Tool = {
+    name: "read_file",
+    stateScope: "call",
+    revalidate: ["sandboxRoots"],
+    prepare(call, ctx) {
+        let path: string;
+        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: any) {
+            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/src/agent/tools/read_many.ts

@@ -0,0 +1,45 @@
+import { readManyResult } from "./readers.js";
+import type { Tool } from "./types.js";
+import { invalid, optionalNumber, preparePath, stringArray } from "./validate.js";
+
+export const readManyTool: Tool = {
+    name: "read_many",
+    stateScope: "call",
+    revalidate: ["sandboxRoots"],
+    prepare(call, ctx) {
+        let paths: string[];
+        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: any) {
+            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,
+        };
+    },
+};