@datename/fastcode-termux 0.0.0-stage → 0.1.6-beta

package/src/agent/guards.ts

@@ -0,0 +1,270 @@
+import { normalize, resolve } from "node:path";
+
+/**
+ * Dangerous-command guard.
+ *
+ * Blocks destructive shell patterns before execution. Word-boundary escapes
+ * are written as character classes so the intent is identical without
+ * boundary syntax.
+ *
+ * Overrides:
+ *   FASTCODE_ALLOW_DANGEROUS=1        bypass the deny list (reported in output)
+ *   FASTCODE_SHELL_ALLOWLIST=a;b      only commands matching these regexes run
+ *   FASTCODE_SHELL_DENY_EXTRA=x;y     extra regexes to deny
+ *   FASTCODE_RESTRICT_TO_WORKSPACE=1  also reject ../ and .. escapes
+ */
+export const DEFAULT_DENY_PATTERNS = [
+    "(^|[^a-z])rm +-[rf]{1,2}([^a-z]|$)",
+    "(^|[^a-z])del +/[fq]([^a-z]|$)",
+    "(^|[^a-z])rmdir +/s([^a-z]|$)",
+    "(^|[^a-z-])(format|mkfs|diskpart)([^a-z]|$)",
+    "(^|[^a-z])dd +if=",
+    "> */dev/sd",
+    "(^|[^a-z])(shutdown|reboot|poweroff)([^a-z]|$)",
+];
+export const FORK_BOMB_MARKERS = [":(){", ":|:&"];
+function enabled(name) {
+    const value = process.env[name];
+    if (value === undefined)
+        return false;
+    return ["1", "true", "yes", "on"].includes(value.trim().toLowerCase());
+}
+function splitList(value) {
+    return (value ?? "").split(/[;,]/).map((entry) => entry.trim()).filter(Boolean);
+}
+function matches(lower, pattern) {
+    try {
+        return new RegExp(pattern).test(lower);
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Decide whether a shell command may run.
+ * Returns { allow: true } or { allow: false, output: explanation }.
+ */
+export function evaluateShellCommand(command) {
+    const cmd = String(command ?? "").trim();
+    const lower = cmd.toLowerCase();
+    if (enabled("FASTCODE_ALLOW_DANGEROUS"))
+        return { allow: true, output: undefined, bypassed: true };
+    const deny = DEFAULT_DENY_PATTERNS.concat(splitList(process.env["FASTCODE_SHELL_DENY_EXTRA"]));
+    for (const pattern of deny) {
+        if (matches(lower, pattern)) {
+            return {
+                allow: false,
+                pattern,
+                output: "Error: blocked by the safety guard (dangerous pattern: " + pattern + "). " +
+                    "Set FASTCODE_ALLOW_DANGEROUS=1 to override.",
+            };
+        }
+    }
+    for (const marker of FORK_BOMB_MARKERS) {
+        if (lower.includes(marker))
+            return { allow: false, output: "Error: blocked by the safety guard (fork bomb pattern)." };
+    }
+    const allowlist = splitList(process.env["FASTCODE_SHELL_ALLOWLIST"]);
+    if (allowlist.length > 0 && !allowlist.some((pattern) => matches(lower, pattern)))
+        return { allow: false, output: "Error: blocked by the safety guard (not in FASTCODE_SHELL_ALLOWLIST)." };
+    if (enabled("FASTCODE_RESTRICT_TO_WORKSPACE")) {
+        const backslash = String.fromCharCode(92);
+        if (cmd.includes("../") || cmd.includes(".." + backslash))
+            return { allow: false, output: "Error: blocked by the safety guard (path traversal)." };
+    }
+    return { allow: true, output: undefined };
+}
+export const READ_ONLY_TOOLS = new Set([
+    "pwd", "read_file", "read_many", "list_files", "grep", "stat_path",
+]);
+const READ_ONLY_COMMANDS = new Set([
+    "pwd", "ls", "dir", "cat", "head", "tail", "wc", "stat", "file", "du", "df",
+    "grep", "rg", "egrep", "fgrep", "which", "whereis", "where", "whoami", "id",
+    "groups", "uname", "date", "uptime", "printenv", "echo", "printf",
+    "true", "false", "basename", "dirname", "realpath", "readlink", "tree",
+    "more", "less", "jq", "cut", "tr",
+]);
+const READ_ONLY_PREFIXES = new Set([
+    "git status", "git diff", "git log", "git show", "git rev-parse",
+    "git ls-files", "git blame", "git grep", "git describe", "git merge-base",
+    "git cat-file", "git rev-list", "git shortlog", "git whatchanged",
+    "npm ls", "npm list", "npm view", "npm outdated", "npm explain", "npm why",
+    "pnpm list", "pnpm ls", "yarn list", "yarn info",
+    "cargo tree", "go list", "pip list", "pip show",
+    "docker ps", "docker images", "docker logs",
+]);
+const NON_READ_ONLY_LEADERS = new Set([
+    "cd", "sudo", "doas", "env", "xargs", "time", "command", "eval", "exec",
+    "source", ".", "sh", "bash", "zsh", "fish", "powershell", "cmd",
+]);
+function scanCommand(command, onChar) {
+    let quote = "";
+    let escaped = false;
+    for (let i = 0; i < command.length; i += 1) {
+        const char = command[i];
+        if (escaped) {
+            escaped = false;
+            onChar(char, i, quote);
+            continue;
+        }
+        if (char === "\\") {
+            escaped = true;
+            onChar(char, i, quote);
+            continue;
+        }
+        if (quote) {
+            if (char === quote)
+                quote = "";
+            onChar(char, i, quote);
+            continue;
+        }
+        if (char === '"' || char === "'") {
+            quote = char;
+            onChar(char, i, quote);
+            continue;
+        }
+        onChar(char, i, quote);
+    }
+    return quote === "";
+}
+function hasWriteRedirection(command) {
+    let found = false;
+    const balanced = scanCommand(command, (char, index, quote) => {
+        if (quote || char !== ">")
+            return;
+        const previous = command[index - 1];
+        if (previous === "=")
+            return;
+        found = true;
+    });
+    return !balanced || found;
+}
+function hasCommandSubstitution(command) {
+    let found = false;
+    const balanced = scanCommand(command, (char, index, quote) => {
+        if (quote)
+            return;
+        if (char === "`" || (char === "$" && command[index + 1] === "("))
+            found = true;
+    });
+    return !balanced || found;
+}
+export function splitCommandSegments(command) {
+    const parts = [];
+    let current = "";
+    let quote = "";
+    let escaped = false;
+    for (let i = 0; i < command.length; i += 1) {
+        const char = command[i];
+        if (escaped) {
+            current += char;
+            escaped = false;
+            continue;
+        }
+        if (char === "\\") {
+            current += char;
+            escaped = true;
+            continue;
+        }
+        if (quote) {
+            current += char;
+            if (char === quote)
+                quote = "";
+            continue;
+        }
+        if (char === '"' || char === "'") {
+            quote = char;
+            current += char;
+            continue;
+        }
+        const next = command[i + 1];
+        if ((char === "&" && next === "&") || (char === "|" && next === "|")) {
+            parts.push(current);
+            current = "";
+            i += 1;
+            continue;
+        }
+        if (char === ";" || char === "|" || char === "&" || char === "\n") {
+            parts.push(current);
+            current = "";
+            continue;
+        }
+        current += char;
+    }
+    parts.push(current);
+    return parts.map((part) => part.trim()).filter(Boolean);
+}
+function isReadOnlySegment(segment) {
+    const tokens = segment.split(/\s+/).filter(Boolean);
+    if (tokens.length === 0)
+        return true;
+    const first = tokens[0].toLowerCase();
+    const second = (tokens[1] ?? "").toLowerCase();
+    if (NON_READ_ONLY_LEADERS.has(first))
+        return false;
+    if (READ_ONLY_PREFIXES.has(first + " " + second))
+        return true;
+    if (READ_ONLY_COMMANDS.has(first))
+        return true;
+    return false;
+}
+export function isReadOnlyCommand(command) {
+    const cmd = String(command ?? "").trim();
+    if (!cmd)
+        return false;
+    if (hasWriteRedirection(cmd) || hasCommandSubstitution(cmd))
+        return false;
+    const segments = splitCommandSegments(cmd);
+    if (segments.length === 0)
+        return false;
+    return segments.every(isReadOnlySegment);
+}
+export function isReadOnlyToolCall(call) {
+    const tool = typeof call?.tool === "string" ? call.tool : "";
+    if (tool === "shell")
+        return isReadOnlyCommand(call.command);
+    return READ_ONLY_TOOLS.has(tool);
+}
+export function loopExemptTools() {
+    const raw = process.env["FASTCODE_LOOP_EXEMPT"] ?? "";
+    return new Set(raw.split(",").map((entry) => entry.trim()).filter(Boolean));
+}
+export function isLoopExempt(tool) {
+    return loopExemptTools().has(String(tool ?? ""));
+}
+function stableValue(value) {
+    if (value === undefined)
+        return "null";
+    if (value === null || typeof value !== "object")
+        return JSON.stringify(value);
+    if (Array.isArray(value))
+        return "[" + value.map((entry) => stableValue(entry)).join(",") + "]";
+    const keys = Object.keys(value).sort().filter((key) => value[key] !== undefined);
+    return "{" + keys.map((key) => JSON.stringify(key) + ":" + stableValue(value[key])).join(",") + "}";
+}
+export function stableStringify(value) {
+    return stableValue(value);
+}
+function normalizeFingerprintPath(value, cwd) {
+    let normalized = normalize(resolve(cwd, value));
+    if (normalized.length > 1)
+        normalized = normalized.replace(/[\\/]+$/, "");
+    return normalized;
+}
+function fingerprintValue(key, value, cwd) {
+    if (typeof value === "string" && (key === "path" || key === "from" || key === "to" || key === "cwd"))
+        return normalizeFingerprintPath(value, cwd);
+    if (key === "paths" && Array.isArray(value))
+        return value.map((entry) => typeof entry === "string" ? normalizeFingerprintPath(entry, cwd) : entry);
+    return value;
+}
+export function toolCallFingerprint(call, cwd = process.cwd()) {
+    const tool = typeof call?.tool === "string" ? call.tool : "unknown";
+    const args = {};
+    for (const key of Object.keys(call ?? {}).sort()) {
+        if (key === "tool" || key === "timeoutMs")
+            continue;
+        args[key] = fingerprintValue(key, call[key], cwd);
+    }
+    return tool + ":" + stableStringify(args);
+}

package/src/agent/ignore.ts

@@ -0,0 +1,147 @@
+/**
+ * Ignore rules for directory walks and reads.
+ *
+ * Defaults cover the usual dependency/build folders. Users can add more with
+ * `.fastcodeignore` in the project root, using a gitignore-like syntax:
+ *
+ *   node_modules/     # trailing slash = directories only
+ *   *.log             # basename at any depth
+ *   /secrets.txt      # anchored to the project root
+ *   !important.log    # re-include (last matching rule wins)
+ */
+import { readFileSync, statSync } from "node:fs";
+import { join, relative, sep } from "node:path";
+
+const DEFAULT_NAMES = new Set([
+    "node_modules",
+    ".git",
+    ".hg",
+    ".svn",
+    "dist",
+    "build",
+    "out",
+    ".next",
+    ".nuxt",
+    ".output",
+    ".turbo",
+    ".parcel-cache",
+    ".cache",
+    "coverage",
+    ".nyc_output",
+    "__pycache__",
+    ".venv",
+    "venv",
+    "target",
+    ".gradle",
+    ".idea",
+]);
+
+const BINARY_EXT = /\.(png|jpe?g|gif|webp|ico|bmp|tiff?|pdf|zip|gz|tgz|bz2|xz|7z|rar|exe|dll|so|dylib|bin|wasm|mp3|mp4|mov|avi|mkv|wav|flac|ttf|otf|woff2?|eot|class|jar|apk|ipa|sqlite|db|lock)$/i;
+
+export interface IgnoreRule {
+    regex: RegExp;
+    negate: boolean;
+    dirOnly: boolean;
+}
+
+export interface IgnoreMatcher {
+    ignored(name: string, fullPath: string, isDir: boolean): boolean;
+    isBinary(name: string): boolean;
+}
+
+export function isBinaryName(name: string): boolean {
+    return BINARY_EXT.test(name);
+}
+
+export function createIgnore(root: string): IgnoreMatcher {
+    const rules = loadRules(root);
+    return {
+        ignored(name, fullPath, isDir) {
+            if (DEFAULT_NAMES.has(name))
+                return true;
+            if (rules.length === 0)
+                return false;
+            const rel = relative(root, fullPath).split(sep).join("/");
+            let ignored = false;
+            for (const rule of rules) {
+                if (rule.dirOnly && !isDir)
+                    continue;
+                if (rule.regex.test(rel) || rule.regex.test(name))
+                    ignored = !rule.negate;
+            }
+            return ignored;
+        },
+        isBinary(name) {
+            return BINARY_EXT.test(name);
+        },
+    };
+}
+
+function loadRules(root: string): IgnoreRule[] {
+    const file = join(root, ".fastcodeignore");
+    let text = "";
+    try {
+        const info = statSync(file);
+        if (!info.isFile())
+            return [];
+        text = readFileSync(file, "utf8");
+    }
+    catch {
+        return [];
+    }
+    const rules: IgnoreRule[] = [];
+    for (const raw of text.split(/\r?\n/)) {
+        const line = raw.trim();
+        if (!line || line.startsWith("#"))
+            continue;
+        const negate = line.startsWith("!");
+        const body = negate ? line.slice(1).trim() : line;
+        if (!body)
+            continue;
+        const dirOnly = body.endsWith("/");
+        const pattern = dirOnly ? body.slice(0, -1) : body;
+        const anchored = pattern.startsWith("/");
+        const glob = anchored ? pattern.slice(1) : pattern;
+        try {
+            rules.push({
+                regex: globToRegExp(glob, anchored),
+                negate,
+                dirOnly,
+            });
+        }
+        catch {
+            // A bad pattern must not disable the whole ignore file.
+        }
+    }
+    return rules;
+}
+
+function globToRegExp(glob: string, anchored: boolean): RegExp {
+    let source = "";
+    for (let i = 0; i < glob.length; i += 1) {
+        const char = glob[i];
+        if (char === "*") {
+            if (glob[i + 1] === "*") {
+                source += ".*";
+                i += 1;
+                if (glob[i + 1] === "/")
+                    i += 1;
+            }
+            else {
+                source += "[^/]*";
+            }
+        }
+        else if (char === "?") {
+            source += "[^/]";
+        }
+        else {
+            source += escapeRegExp(char);
+        }
+    }
+    // Unanchored patterns match a basename at any depth.
+    return new RegExp("^" + (anchored ? "" : "(?:.*/)?") + source + "$");
+}
+
+function escapeRegExp(value: string): string {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}

package/src/agent/limits.ts

@@ -0,0 +1,71 @@
+/**
+ * Single source of truth for how much tool output reaches the model.
+ *
+ * Output is bounded while it is produced, not by slicing a finished string
+ * afterwards, so a runaway command or a huge directory listing cannot grow
+ * without limit. Override the cap with FASTCODE_TOOL_OUTPUT_LIMIT (characters).
+ */
+export const DEFAULT_TOOL_OUTPUT_LIMIT = 30000;
+export function toolOutputLimit() {
+    const raw = Number(process.env["FASTCODE_TOOL_OUTPUT_LIMIT"]);
+    return Number.isFinite(raw) && raw > 0 ? Math.floor(raw) : DEFAULT_TOOL_OUTPUT_LIMIT;
+}
+/**
+ * Bounded text accumulator.
+ *
+ * mode "head" keeps the first N characters (listings, search hits);
+ * mode "tail" keeps the last N (command logs, where the error is last).
+ * trimEnd()/toString() mimic a plain string so callers stay simple.
+ */
+export function createOutputBuffer(limit = toolOutputLimit(), mode = "head") {
+    const NL = String.fromCharCode(10);
+    let text = "";
+    let dropped = 0;
+    const buffer = {
+        get full() {
+            return text.length >= limit;
+        },
+        push(chunk) {
+            const value = String(chunk);
+            if (mode === "tail") {
+                text += value;
+                if (text.length > limit) {
+                    const over = text.length - limit;
+                    dropped += over;
+                    text = text.slice(over);
+                }
+                return;
+            }
+            if (text.length >= limit) {
+                dropped += value.length;
+                return;
+            }
+            const room = limit - text.length;
+            if (value.length <= room) {
+                text += value;
+            }
+            else {
+                text += value.slice(0, room);
+                dropped += value.length - room;
+            }
+        },
+        line(value) {
+            if (text.length > 0)
+                buffer.push(NL);
+            buffer.push(value);
+        },
+        value() {
+            if (dropped <= 0)
+                return text;
+            const note = "[" + dropped + " more characters omitted]";
+            return mode === "tail" ? note + NL + text : text + NL + note;
+        },
+        trimEnd() {
+            return buffer.value().trimEnd();
+        },
+        toString() {
+            return buffer.value();
+        },
+    };
+    return buffer;
+}

package/src/agent/process-tree.ts

@@ -0,0 +1,32 @@
+import { spawn, type ChildProcess } from "node:child_process";
+
+export function killProcessTree(child: ChildProcess | undefined, signal: NodeJS.Signals = "SIGTERM"): void {
+  if (!child || typeof child.pid !== "number")
+    return;
+  if (process.platform === "win32") {
+    try {
+      const killer = spawn("taskkill", ["/pid", String(child.pid), "/T", "/F"], { windowsHide: true, stdio: "ignore" });
+      killer.unref();
+    }
+    catch {
+      try {
+        child.kill();
+      }
+      catch {
+        // The process may already be gone.
+      }
+    }
+    return;
+  }
+  try {
+    process.kill(-child.pid, signal);
+  }
+  catch {
+    try {
+      child.kill(signal);
+    }
+    catch {
+      // Same as above.
+    }
+  }
+}

package/src/agent/protocol-mode.ts

@@ -0,0 +1,59 @@
+import { getModelMeta } from "../lib/model-meta.js";
+
+export type ToolProtocol = "legacy" | "native";
+export type ToolCapability = "native" | "pseudo";
+
+const NATIVE_PROVIDERS = new Set([
+    "openai",
+    "openrouter",
+    "deepseek",
+    "groq",
+    "mistral",
+    "xai",
+    "moonshot",
+    "zhipu",
+    "qwen",
+    "ollama",
+]);
+
+export function toolCapabilityKey(providerId: string, model: string): string {
+    return `${providerId}::${model}`;
+}
+
+export function resolveToolProtocol(config: any, providerId: string, model: string, env = process.env): ToolProtocol {
+    const mode = String(env["FASTCODE_TOOL_PROTOCOL"] ?? "legacy").trim().toLowerCase();
+    if (mode === "legacy")
+        return "legacy";
+    if (mode === "native")
+        return "native";
+    if (mode !== "auto")
+        return "legacy";
+    const cached = config?.capabilities?.toolCalling?.[toolCapabilityKey(providerId, model)];
+    if (cached === "pseudo")
+        return "legacy";
+    if (cached === "native")
+        return "native";
+    if (!NATIVE_PROVIDERS.has(providerId))
+        return "legacy";
+    return getModelMeta(providerId, model).supportsTools ? "native" : "legacy";
+}
+
+export function withToolCapability(config: any, providerId: string, model: string, capability: ToolCapability): any {
+    const key = toolCapabilityKey(providerId, model);
+    return {
+        ...config,
+        capabilities: {
+            ...(config?.capabilities ?? {}),
+            toolCalling: {
+                ...(config?.capabilities?.toolCalling ?? {}),
+                [key]: capability,
+            },
+        },
+    };
+}
+
+export function isNativeUnsupportedError(message: string): boolean {
+    return /\b400\b/.test(message)
+        && /tool|function/i.test(message)
+        && /not supported|unsupported|unrecognized|unknown|invalid|does not support/i.test(message);
+}