@datename/fastcode-termux 0.0.0-stage → 0.1.6

package/dist/agent/protocol.js

@@ -0,0 +1,126 @@
+const TOOL_RE = /<fastcode_tool>([\s\S]*?)<\/fastcode_tool>/g;
+// Some models (notably DeepSeek) emit their native "DSML" tool-call markup
+// instead of <fastcode_tool>. The markers look like `<｜DSML｜invoke ...>`
+// (U+FF5C fullwidth bar, sometimes doubled or spaced). We canonicalize those
+// markers back to plain angle-bracket tags and then parse the
+// calls -> invoke -> parameter structure as a second dialect.
+const DSML_OPEN_RE = /<\s*(?:[|｜]\s*)+DSML\s*(?:[|｜]\s*)+/gi;
+const DSML_CLOSE_RE = /<\/\s*(?:[|｜]\s*)+DSML\s*(?:[|｜]\s*)+/gi;
+const DSML_BLOCK_RE = /<([a-z_]*calls?)>([\s\S]*?)<\/\1>/gi;
+const DSML_INVOKE_RE = /<invoke\s+name="([^"]+)"\s*>([\s\S]*?)<\/invoke>/gi;
+const DSML_PARAM_RE = /<parameter\s+name="([^"]+)"([^>]*)>([\s\S]*?)<\/parameter>/gi;
+/** Turn the DSML glyph markers into ordinary `<tag>` / `</tag>` tags. */
+function canonicalizeDsml(text) {
+    return text.replace(DSML_CLOSE_RE, "</").replace(DSML_OPEN_RE, "<");
+}
+function coerceDsmlValue(attrs, raw) {
+    const value = raw.replace(/^\n/, "").replace(/\n$/, "");
+    if (/\bstring\s*=\s*"true"/i.test(attrs))
+        return value;
+    const trimmed = value.trim();
+    if (trimmed === "")
+        return "";
+    try {
+        return JSON.parse(trimmed);
+    }
+    catch {
+        if (trimmed === "true")
+            return true;
+        if (trimmed === "false")
+            return false;
+        const n = Number(trimmed);
+        return Number.isNaN(n) ? value : n;
+    }
+}
+function parseDsmlCalls(text) {
+    const canonical = canonicalizeDsml(text);
+    const bodies = [];
+    for (const block of canonical.matchAll(DSML_BLOCK_RE))
+        bodies.push(block[2] ?? "");
+    if (bodies.length === 0)
+        bodies.push(canonical);
+    const calls = [];
+    for (const body of bodies) {
+        for (const invoke of body.matchAll(DSML_INVOKE_RE)) {
+            const call = { tool: invoke[1] };
+            for (const param of (invoke[2] ?? "").matchAll(DSML_PARAM_RE))
+                call[param[1]] = coerceDsmlValue(param[2] ?? "", param[3] ?? "");
+            calls.push(call);
+        }
+    }
+    return calls;
+}
+export function parseToolCalls(text) {
+    const calls = [];
+    for (const match of text.matchAll(TOOL_RE)) {
+        const raw = match[1]?.trim();
+        if (!raw)
+            continue;
+        try {
+            const parsed = JSON.parse(raw);
+            if (typeof parsed.tool === "string")
+                calls.push(parsed);
+        }
+        catch {
+            // Ignore malformed tool blocks; the model can correct itself next turn.
+        }
+    }
+    calls.push(...parseDsmlCalls(text));
+    return calls;
+}
+export function stripToolCalls(text) {
+    return canonicalizeDsml(text).replace(TOOL_RE, "").replace(DSML_BLOCK_RE, "").trim();
+}
+export function formatToolResults(results) {
+    const blocks = results.map((r, index) => {
+        const status = r.ok ? "ok" : "error";
+        return [
+            `Tool result ${index + 1} (${status})`,
+            `call: ${JSON.stringify(r.call)}`,
+            "output:",
+            fence(r.output),
+        ].join("\n");
+    });
+    return [
+        "FastCode executed the requested local tools. Use these results to continue.",
+        ...blocks,
+    ].join("\n\n");
+}
+export const AGENT_SYSTEM_PROMPT = `
+You are FastCode Agent, a local coding agent running inside the user's terminal.
+Tools run inside a filesystem sandbox rooted at the current working directory.
+File tools cannot access paths outside that root. Shell commands run with FASTCODE_SANDBOX=1 and FASTCODE_SANDBOX_ROOT set.
+
+You can inspect and change the user's machine by emitting exactly one or more tool calls in this format:
+<fastcode_tool>{"tool":"shell","command":"npm test"}</fastcode_tool>
+
+Available tools:
+- shell: {"tool":"shell","command":"command to run"}
+- shell with timeout: {"tool":"shell","command":"npm test","timeoutMs":120000}
+- pwd: {"tool":"pwd"}
+- read_file: {"tool":"read_file","path":"path/to/file"}
+- read_many: {"tool":"read_many","paths":["file1","file2"]}
+- write_file: {"tool":"write_file","path":"path/to/file","content":"full file contents"}
+- append_file: {"tool":"append_file","path":"path/to/file","content":"text to append"}
+- apply_patch: {"tool":"apply_patch","patch":"*** Begin Patch\\n*** Update File: path\\n@@\\n-old\\n+new\\n*** End Patch\\n"}
+- list_files: {"tool":"list_files","path":"optional/path","maxDepth":2}
+- grep: {"tool":"grep","pattern":"text or regex","path":"optional/path"}
+- replace_in_file: {"tool":"replace_in_file","path":"path/to/file","find":"exact text","replace":"replacement"}
+- stat_path: {"tool":"stat_path","path":"path/to/file"}
+- make_dir: {"tool":"make_dir","path":"path/to/dir"}
+- copy_file: {"tool":"copy_file","from":"src","to":"dest"}
+- move_path: {"tool":"move_path","from":"src","to":"dest"}
+- delete_file: {"tool":"delete_file","path":"path/to/file"}
+
+Rules:
+- Prefer inspecting files before editing.
+- Use shell for tests, builds, package scripts, git inspection, and OS commands.
+- Use apply_patch or replace_in_file for focused edits.
+- Use write_file only when replacing the whole file is appropriate.
+- Run verification commands after code changes.
+- After tool results come back, continue working until the user's request is done.
+- When done, answer normally without tool calls.
+`.trim();
+function fence(text) {
+    return `\`\`\`\n${text}\n\`\`\``;
+}

package/dist/agent/tools.d.ts

@@ -0,0 +1 @@
+export declare function runAgentTool(call: any, cwd?: string): Promise<unknown>;

package/dist/agent/tools.js

@@ -0,0 +1,377 @@
+import { spawn } from "node:child_process";
+import { appendFile, copyFile, mkdir, readdir, readFile, realpath, rm, rename, stat, writeFile, } from "node:fs/promises";
+import { existsSync, realpathSync } from "node:fs";
+import { basename, delimiter, dirname, isAbsolute, join, relative, resolve } from "node:path";
+import { detectPlatform } from "../lib/platform.js";
+import { evaluateShellCommand } from "./guards.js";
+import { createOutputBuffer } from "./limits.js";
+export async function runAgentTool(call, cwd = process.cwd()) {
+    const sandbox = resolve(cwd);
+    try {
+        switch (call.tool) {
+            case "shell":
+                return await runShell(requiredString(call, "command"), sandbox, numberOption(call.timeoutMs, 120000));
+            case "pwd":
+                return { ok: true, output: sandbox };
+            case "read_file":
+                return { ok: true, output: await readFile(resolvePath(sandbox, call), "utf8") };
+            case "read_many":
+                return { ok: true, output: await readMany(sandbox, stringArray(call, "paths")) };
+            case "write_file": {
+                const file = resolvePath(sandbox, call);
+                await mkdir(dirname(file), { recursive: true });
+                await writeFile(file, requiredString(call, "content"), "utf8");
+                return { ok: true, output: `wrote ${file}` };
+            }
+            case "append_file": {
+                const file = resolvePath(sandbox, call);
+                await mkdir(dirname(file), { recursive: true });
+                await appendFile(file, requiredString(call, "content"), "utf8");
+                return { ok: true, output: `appended ${file}` };
+            }
+            case "apply_patch":
+                return await applyPatch(sandbox, requiredString(call, "patch"));
+            case "copy_file": {
+                const from = sandboxPath(sandbox, requiredString(call, "from"));
+                const to = sandboxPath(sandbox, requiredString(call, "to"));
+                await mkdir(dirname(to), { recursive: true });
+                await copyFile(from, to);
+                return { ok: true, output: `copied ${from} to ${to}` };
+            }
+            case "delete_file": {
+                const file = resolvePath(sandbox, call);
+                await rm(file, { recursive: true, force: true });
+                return { ok: true, output: `deleted ${file}` };
+            }
+            case "list_files":
+                return { ok: true, output: await listFiles(sandbox, resolvePath(sandbox, call, "."), numberOption(call.maxDepth, 2)) };
+            case "make_dir": {
+                const dir = resolvePath(sandbox, call);
+                await mkdir(dir, { recursive: true });
+                return { ok: true, output: `created ${dir}` };
+            }
+            case "move_path": {
+                const from = sandboxPath(sandbox, requiredString(call, "from"));
+                const to = sandboxPath(sandbox, requiredString(call, "to"));
+                await mkdir(dirname(to), { recursive: true });
+                await rename(from, to);
+                return { ok: true, output: `moved ${from} to ${to}` };
+            }
+            case "grep":
+                return {
+                    ok: true,
+                    output: await grepFiles(sandbox, resolvePath(sandbox, call, "."), requiredString(call, "pattern"), numberOption(call.maxDepth, 4)),
+                };
+            case "replace_in_file": {
+                const file = resolvePath(sandbox, call);
+                const find = requiredString(call, "find");
+                const replacement = requiredString(call, "replace");
+                const source = await readFile(file, "utf8");
+                if (!source.includes(find))
+                    return { ok: false, output: `text not found in ${file}` };
+                await writeFile(file, source.split(find).join(replacement), "utf8");
+                return { ok: true, output: `replaced text in ${file}` };
+            }
+            case "stat_path": {
+                const file = resolvePath(sandbox, call);
+                const info = await stat(file);
+                return {
+                    ok: true,
+                    output: JSON.stringify({
+                        path: file,
+                        type: info.isDirectory() ? "dir" : info.isFile() ? "file" : "other",
+                        size: info.size,
+                        modified: info.mtime.toISOString(),
+                    }, null, 2),
+                };
+            }
+            default:
+                return { ok: false, output: `unknown tool: ${String(call.tool)}` };
+        }
+    }
+    catch (err) {
+        return { ok: false, output: err.message };
+    }
+}
+async function runShell(command, cwd, timeoutMs) {
+    const verdict = evaluateShellCommand(command);
+    if (!verdict.allow)
+        return { ok: false, output: verdict.output };
+    return await new Promise((resolvePromise) => {
+        const child = spawn(command, {
+            cwd,
+            shell: true,
+            env: { ...process.env, FASTCODE_SANDBOX: "1", FASTCODE_SANDBOX_ROOT: cwd },
+            windowsHide: true,
+        });
+        const timeout = setTimeout(() => {
+            child.kill("SIGTERM");
+            resolvePromise({ ok: false, output: `command timed out after ${timeoutMs}ms\n${output.trimEnd()}` });
+        }, timeoutMs);
+        const output = createOutputBuffer(undefined, "tail");
+        const collect = (chunk) => {
+            output.push(chunk.toString("utf8"));
+        };
+        child.stdout.on("data", collect);
+        child.stderr.on("data", collect);
+        child.on("error", (err) => {
+            clearTimeout(timeout);
+            resolvePromise({ ok: false, output: err.message });
+        });
+        child.on("close", (code) => {
+            clearTimeout(timeout);
+            resolvePromise({
+                ok: code === 0,
+                output: output.trimEnd(),
+            });
+        });
+    });
+}
+async function readMany(cwd, paths) {
+    const blocks = [];
+    for (const path of paths) {
+        const file = sandboxPath(cwd, path);
+        blocks.push(`### ${file}\n${await readFile(file, "utf8")}`);
+    }
+    return blocks.join("\n\n");
+}
+async function listFiles(sandbox, root, maxDepth) {
+    const out = createOutputBuffer();
+    await walkWithin(sandbox, root, maxDepth, async (file, info) => {
+        out.line((info.isDirectory() ? "dir " : "file") + " " + file);
+        return !out.full;
+    });
+    return out.value();
+}
+async function grepFiles(sandbox, root, pattern, maxDepth) {
+    const re = new RegExp(pattern, "i");
+    const out = createOutputBuffer();
+    await walkWithin(sandbox, root, maxDepth, async (file, info) => {
+        if (!info.isFile())
+            return;
+        try {
+            const text = await readFile(file, "utf8");
+            const lines = text.split(/\r?\n/);
+            lines.forEach((line, index) => {
+                if (re.test(line))
+                    out.line(file + ":" + (index + 1) + ": " + line);
+            });
+        }
+        catch {
+            // Binary or unreadable files are skipped.
+        }
+        return !out.full;
+    });
+    return out.value();
+}
+/** Start a walk bounded to the sandbox plus every allowed extra root. */
+async function walkWithin(sandbox, root, maxDepth, visit) {
+    const roots = allowedRoots(sandbox).map((entry) => realpathOf(entry)).filter(Boolean);
+    await walk(root, maxDepth, visit, 0, { roots, visited: 0, maxVisited: 5000 }, []);
+}
+/**
+ * Tolerant recursive walk.
+ *
+ * stat() follows symlinks, so a dangling link (common on Termux: after
+ * termux-setup-storage the ~/storage/* links break once the phone-side folder
+ * is deleted) throws ENOENT. One bad entry must never abort the whole walk, so
+ * every stat/readdir/visit is guarded individually.
+ *
+ * Valid symlinks are followed. Recursion stops only where the real target is
+ * outside every allowed root: the sandbox, FASTCODE_ALLOW_PATHS, and on Termux
+ * ~/storage/shared (allowed by default). A per-branch chain of real paths breaks
+ * symlink cycles (loop -> ancestor) without hiding legitimate sibling symlinks.
+ */
+async function walk(node, maxDepth, visit, depth = 0, state, chain = []) {
+    if (state.visited >= state.maxVisited)
+        return;
+    let info;
+    try {
+        info = await stat(node);
+    }
+    catch {
+        return; // dangling symlink or unreadable entry: skip it, keep going
+    }
+    let real;
+    try {
+        real = await realpath(node);
+    }
+    catch {
+        real = node;
+    }
+    if (chain.includes(real))
+        return;
+    state.visited += 1;
+    const insideSandbox = !state.roots || state.roots.length === 0 || isInsideAny(real, state.roots);
+    let keepGoing = true;
+    try {
+        keepGoing = (await visit(node, info)) !== false;
+    }
+    catch {
+        // A visitor failure must not abort the surrounding walk.
+    }
+    if (!keepGoing)
+        return false;
+    if (!info.isDirectory() || depth >= maxDepth || !insideSandbox)
+        return;
+    let entries;
+    try {
+        entries = await readdir(node, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    const nextChain = chain.concat(real);
+    for (const entry of entries) {
+        if (entry.name === "node_modules" || entry.name === ".git" || entry.name === "dist")
+            continue;
+        if (state.visited >= state.maxVisited)
+            return;
+        try {
+            const keepWalking = await walk(join(node, entry.name), maxDepth, visit, depth + 1, state, nextChain);
+            if (keepWalking === false)
+                return false;
+        }
+        catch {
+            // Keep walking siblings.
+        }
+    }
+}
+/**
+ * Roots the agent may touch: the sandbox (cwd) plus configured extras.
+ *
+ * Termux users keep projects and downloads in shared storage, so on Termux
+ * ~/storage/shared (-> /storage/emulated/0) is allowed by default.
+ *
+ *   FASTCODE_ALLOW_PATHS=/sdcard/projects:/sdcard/Download   extra roots
+ *   FASTCODE_ALLOW_SHARED_STORAGE=0                          disable the default
+ */
+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));
+    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;
+}
+function isDisabled(value) {
+    if (value === undefined)
+        return false;
+    return ["0", "false", "no", "off"].includes(value.trim().toLowerCase());
+}
+function isInsideAny(child, roots) {
+    return roots.some((root) => {
+        const rel = relative(root, child);
+        return rel === "" || (!rel.startsWith("..") && !isAbsolute(rel));
+    });
+}
+function resolvePath(cwd, call, fallback = "") {
+    const raw = typeof call.path === "string" ? call.path : fallback;
+    return sandboxPath(cwd, raw);
+}
+function sandboxPath(cwd, raw) {
+    const target = resolve(cwd, raw);
+    const roots = allowedRoots(cwd);
+    // Real-path containment is authoritative: it is the only check that sees
+    // through symlinks, so a link planted inside the sandbox cannot escape.
+    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);
+    }
+    // realpathOf() returns undefined only when nothing on the chain exists yet,
+    // so a lexical check against the configured roots is safe here.
+    if (isInsideAny(target, roots))
+        return target;
+    throw new Error("path outside sandbox: " + raw);
+}
+/** Resolve a path that may not exist yet by realpath-ing its deepest existing ancestor. */
+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;
+    }
+}
+function requiredString(call, key) {
+    const value = call[key];
+    if (typeof value !== "string")
+        throw new Error(`${key} must be a string`);
+    return value;
+}
+function stringArray(call, key) {
+    const value = call[key];
+    if (!Array.isArray(value) || !value.every((item) => typeof item === "string")) {
+        throw new Error(`${key} must be an array of strings`);
+    }
+    return value;
+}
+function numberOption(value, fallback) {
+    return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}
+async function applyPatch(cwd, patch) {
+    const lines = patch.split(/\r?\n/);
+    if (lines[0] !== "*** Begin Patch")
+        return { ok: false, output: "patch must start with *** Begin Patch" };
+    let i = 1;
+    let changed = 0;
+    while (i < lines.length) {
+        const line = lines[i];
+        if (line === "*** End Patch" || line === "")
+            break;
+        if (!line?.startsWith("*** Update File: ")) {
+            return { ok: false, output: `unsupported patch directive: ${line ?? ""}` };
+        }
+        const relative = line.slice("*** Update File: ".length).trim();
+        const file = resolve(cwd, relative);
+        let source = await readFile(file, "utf8");
+        i += 1;
+        while (i < lines.length && !lines[i]?.startsWith("*** ")) {
+            if (lines[i] === "@@")
+                i += 1;
+            const remove = [];
+            const add = [];
+            while (i < lines.length && lines[i] !== "@@" && !lines[i]?.startsWith("*** ")) {
+                const hunkLine = lines[i] ?? "";
+                if (hunkLine.startsWith("-"))
+                    remove.push(hunkLine.slice(1));
+                if (hunkLine.startsWith("+"))
+                    add.push(hunkLine.slice(1));
+                i += 1;
+            }
+            const needle = `${remove.join("\n")}${remove.length > 0 ? "\n" : ""}`;
+            const replacement = `${add.join("\n")}${add.length > 0 ? "\n" : ""}`;
+            if (needle && !source.includes(needle)) {
+                return { ok: false, output: `patch context not found in ${file}: ${JSON.stringify(needle)}` };
+            }
+            source = needle ? source.replace(needle, replacement) : source + replacement;
+            changed += 1;
+        }
+        await writeFile(file, source, "utf8");
+    }
+    return { ok: true, output: `applied ${changed} patch hunk(s)` };
+}

package/dist/app.d.ts

@@ -0,0 +1,4 @@
+export declare const App: ({ initialPrompt, resume }: {
+    initialPrompt: any;
+    resume: any;
+}) => import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>>;