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

package/dist/agent/shell-session.js

@@ -0,0 +1,400 @@
+import { spawn } from "node:child_process";
+import { killProcessTree } from "./process-tree.js";
+const OUTPUT_LIMIT = 1024 * 1024;
+const DEFAULT_BACKGROUND_MS = 2000;
+const DEFAULT_TIMEOUT_MS = 120_000;
+const MAX_POOL = 2;
+const jobs = new Map();
+const pool = [];
+let spawns = 0;
+let spawnTurn = Number.NaN;
+let spawnsThisTurn = 0;
+class ShellJob {
+    id;
+    key;
+    command;
+    cwd;
+    startedAt = Date.now();
+    output = "";
+    delivered = 0;
+    status = "running";
+    exitCode;
+    nextPollMs = 1000;
+    child;
+    resident;
+    donePromise;
+    resolveDone;
+    waiters = [];
+    constructor(command, cwd) {
+        this.id = "sh_" + Date.now().toString(36) + "_" + Math.random().toString(36).slice(2, 7);
+        this.key = this.id.replace(/[^a-z0-9]/gi, "");
+        this.command = command;
+        this.cwd = cwd;
+        this.donePromise = new Promise((resolve) => {
+            this.resolveDone = resolve;
+        });
+    }
+    done() {
+        return this.donePromise;
+    }
+    append(text) {
+        if (!text)
+            return;
+        this.output += text;
+        if (this.output.length > OUTPUT_LIMIT) {
+            const over = this.output.length - OUTPUT_LIMIT;
+            this.output = this.output.slice(over);
+            this.delivered = Math.max(0, this.delivered - over);
+        }
+        this.notify();
+    }
+    takeOutput() {
+        const next = this.output.slice(this.delivered);
+        this.delivered = this.output.length;
+        return next;
+    }
+    finish(status, exitCode) {
+        if (this.status !== "running")
+            return;
+        this.status = status;
+        this.exitCode = exitCode;
+        this.resolveDone();
+        this.notify();
+    }
+    waitForChange(ms) {
+        if (this.status !== "running" || this.delivered < this.output.length)
+            return Promise.resolve();
+        if (ms <= 0)
+            return Promise.resolve();
+        return new Promise((resolve) => {
+            let timer;
+            const wake = () => {
+                if (timer)
+                    clearTimeout(timer);
+                this.waiters = this.waiters.filter((entry) => entry !== wake);
+                resolve();
+            };
+            this.waiters.push(wake);
+            timer = setTimeout(wake, ms);
+        });
+    }
+    notify() {
+        const waiters = this.waiters;
+        this.waiters = [];
+        for (const waiter of waiters)
+            waiter();
+    }
+    view() {
+        return {
+            id: this.id,
+            command: this.command,
+            cwd: this.cwd,
+            status: this.status,
+            exitCode: this.exitCode,
+            bytes: this.output.length,
+            startedAt: this.startedAt,
+            pid: this.child?.pid,
+        };
+    }
+    kill(reason) {
+        if (this.status !== "running")
+            return;
+        this.append(reason === "timeout" ? "\n[command timed out: process tree killed]" : "\n[command aborted: process tree killed]");
+        this.status = reason;
+        if (this.resident)
+            this.resident.kill();
+        else if (this.child)
+            killProcessTree(this.child, "SIGTERM");
+        this.resolveDone();
+        this.notify();
+    }
+}
+class ResidentShell {
+    child;
+    job;
+    dead = false;
+    buffer = "";
+    constructor(cwd) {
+        const env = { ...process.env, FASTCODE_SANDBOX: "1", FASTCODE_SANDBOX_ROOT: cwd };
+        this.child = spawn("sh", ["-s"], {
+            cwd,
+            env,
+            detached: process.platform !== "win32",
+            windowsHide: true,
+        });
+        this.child.stdout.setEncoding("utf8");
+        this.child.stderr.setEncoding("utf8");
+        this.child.stdout.on("data", (chunk) => this.consume(chunk));
+        this.child.stderr.on("data", (chunk) => this.consume(chunk));
+        this.child.on("error", (err) => {
+            this.fail(err.message);
+        });
+        this.child.on("close", (code) => {
+            this.dead = true;
+            this.fail(`shell exited (${code ?? "unknown"})`, code);
+            const index = pool.indexOf(this);
+            if (index >= 0)
+                pool.splice(index, 1);
+        });
+    }
+    run(job, timeoutMs) {
+        this.job = job;
+        job.resident = this;
+        const marker = `__FC_END_${job.key}__`;
+        const script = [
+            `if cd ${shellQuote(job.cwd)}; then`,
+            job.command,
+            "__fc_status=$?",
+            "else",
+            "__fc_status=1",
+            "fi",
+            `printf '\\n${marker}:%s\\n' "$__fc_status"`,
+            "",
+        ].join("\n");
+        try {
+            this.child.stdin.write(script);
+        }
+        catch (err) {
+            job.append(err?.message ?? String(err));
+            job.finish("failed", 1);
+        }
+        void timeoutMs;
+    }
+    consume(chunk) {
+        if (this.dead)
+            return;
+        this.buffer += chunk;
+        if (!this.job)
+            return;
+        const marker = `__FC_END_${this.job.key}__:`;
+        const index = this.buffer.indexOf(marker);
+        if (index < 0) {
+            const sentinel = "\n" + marker;
+            let keep = 0;
+            const max = Math.min(this.buffer.length, sentinel.length);
+            for (let length = max; length > 0; length -= 1) {
+                if (sentinel.startsWith(this.buffer.slice(this.buffer.length - length))) {
+                    keep = length;
+                    break;
+                }
+            }
+            const flush = this.buffer.length - keep;
+            if (flush > 0) {
+                this.job.append(this.buffer.slice(0, flush));
+                this.buffer = this.buffer.slice(flush);
+            }
+            return;
+        }
+        const rest = this.buffer.slice(index + marker.length);
+        const newline = rest.indexOf("\n");
+        if (newline < 0)
+            return;
+        const job = this.job;
+        job.append(this.buffer.slice(0, index));
+        const code = Number(rest.slice(0, newline).trim());
+        this.buffer = rest.slice(newline + 1);
+        this.job = undefined;
+        job.finish(Number.isFinite(code) && code === 0 ? "done" : "failed", Number.isFinite(code) ? code : 1);
+    }
+    fail(message, code) {
+        if (!this.job)
+            return;
+        const job = this.job;
+        this.job = undefined;
+        job.append(`\n${message}`);
+        job.finish("failed", code ?? 1);
+    }
+    kill() {
+        this.dead = true;
+        killProcessTree(this.child, "SIGTERM");
+        setTimeout(() => killProcessTree(this.child, "SIGKILL"), 2000);
+        const index = pool.indexOf(this);
+        if (index >= 0)
+            pool.splice(index, 1);
+    }
+}
+export async function executeShellCommand(command, cwd, options = {}) {
+    pruneJobs();
+    if (options.signal?.aborted)
+        return { ok: false, status: "killed", output: "command aborted before start" };
+    const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const backgroundAfterMs = options.backgroundAfterMs ?? DEFAULT_BACKGROUND_MS;
+    const useResident = process.platform !== "win32" && !needsOneShot(command);
+    let job;
+    if (useResident) {
+        const resident = acquireResident(options.turn, cwd);
+        if (resident === "busy")
+            return { ok: false, status: "failed", output: "both pool shells are busy; poll or kill a session first" };
+        if (resident === "limit")
+            return { ok: false, status: "failed", output: spawnLimitMessage() };
+        job = new ShellJob(command, cwd);
+        resident.run(job, timeoutMs);
+    }
+    else {
+        if (!maySpawn(options.turn))
+            return { ok: false, status: "failed", output: spawnLimitMessage() };
+        job = startOneShot(command, cwd);
+    }
+    jobs.set(job.id, job);
+    const timer = setTimeout(() => job.kill("timeout"), timeoutMs);
+    const onAbort = () => job.kill("killed");
+    options.signal?.addEventListener("abort", onAbort, { once: true });
+    const cleanup = () => {
+        clearTimeout(timer);
+        options.signal?.removeEventListener("abort", onAbort);
+    };
+    await Promise.race([job.done(), delay(backgroundAfterMs)]);
+    if (job.status === "running") {
+        cleanup();
+        return {
+            ok: true,
+            status: "running",
+            output: job.takeOutput(),
+            sessionId: job.id,
+            nextPollMs: job.nextPollMs,
+        };
+    }
+    cleanup();
+    return syncResult(job);
+}
+export async function pollShellSession(id, waitMs = 0) {
+    pruneJobs();
+    const job = jobs.get(id);
+    if (!job)
+        return undefined;
+    return await pollOnce(job, waitMs);
+}
+async function pollOnce(job, waitMs) {
+    await job.waitForChange(waitMs);
+    const output = job.takeOutput();
+    if (output)
+        job.nextPollMs = 1000;
+    else if (job.status === "running")
+        job.nextPollMs = Math.min(30_000, job.nextPollMs * 2);
+    return {
+        ok: job.status === "done" || job.status === "running",
+        status: job.status,
+        output,
+        exitCode: job.exitCode,
+        sessionId: job.id,
+        nextPollMs: job.nextPollMs,
+    };
+}
+export function killShellSession(id) {
+    const job = jobs.get(id);
+    if (!job || job.status !== "running")
+        return false;
+    job.kill("killed");
+    return true;
+}
+export function listShellSessions() {
+    pruneJobs();
+    return Array.from(jobs.values())
+        .sort((a, b) => b.startedAt - a.startedAt)
+        .map((job) => job.view());
+}
+export function shutdownShells() {
+    for (const job of jobs.values()) {
+        if (job.status === "running")
+            job.kill("killed");
+    }
+    for (const resident of [...pool])
+        resident.kill();
+    pool.length = 0;
+    jobs.clear();
+}
+export function shellPoolStats() {
+    return {
+        spawns,
+        active: Array.from(jobs.values()).filter((job) => job.status === "running").length,
+        pool: pool.filter((resident) => !resident.dead).length,
+        maxSpawnPerTurn: maxSpawnPerTurn(),
+    };
+}
+function startOneShot(command, cwd) {
+    const job = new ShellJob(command, cwd);
+    const child = spawn(command, {
+        cwd,
+        shell: true,
+        env: { ...process.env, FASTCODE_SANDBOX: "1", FASTCODE_SANDBOX_ROOT: cwd },
+        windowsHide: true,
+        detached: process.platform !== "win32",
+    });
+    job.child = child;
+    child.stdout?.on("data", (chunk) => job.append(chunk.toString("utf8")));
+    child.stderr?.on("data", (chunk) => job.append(chunk.toString("utf8")));
+    child.on("error", (err) => {
+        job.append("\n" + err.message);
+        job.finish("failed", 1);
+    });
+    child.on("close", (code) => {
+        if (job.status === "running")
+            job.finish(code === 0 ? "done" : "failed", code);
+    });
+    return job;
+}
+function acquireResident(turn, cwd) {
+    const idle = pool.find((resident) => !resident.dead && !resident.job);
+    if (idle)
+        return idle;
+    if (pool.filter((resident) => !resident.dead).length >= MAX_POOL)
+        return "busy";
+    if (!maySpawn(turn))
+        return "limit";
+    const resident = new ResidentShell(cwd);
+    pool.push(resident);
+    return resident;
+}
+function needsOneShot(command) {
+    return /(^|\s)(vim|nano|less|more|ssh|su|login|read|top|htop|tmux|screen)(\s|$)/.test(command)
+        || /(^|\s)(python|python3|node|bash|zsh|fish|irb|sqlite3)(\s|$)/.test(command) && !/\s-(c|e|m)\s/.test(command);
+}
+function maySpawn(turn) {
+    const current = typeof turn === "number" ? turn : 0;
+    if (current !== spawnTurn) {
+        spawnTurn = current;
+        spawnsThisTurn = 0;
+    }
+    if (spawnsThisTurn >= maxSpawnPerTurn())
+        return false;
+    spawnsThisTurn += 1;
+    spawns += 1;
+    return true;
+}
+function maxSpawnPerTurn() {
+    const raw = Number(process.env["FASTCODE_MAX_SPAWN_PER_TURN"]);
+    return Number.isFinite(raw) && raw > 0 ? Math.floor(raw) : 8;
+}
+function spawnLimitMessage() {
+    return `spawn limit reached (FASTCODE_MAX_SPAWN_PER_TURN=${maxSpawnPerTurn()}); batch commands or poll an existing session`;
+}
+function syncResult(job) {
+    return {
+        ok: job.status === "done",
+        status: job.status,
+        output: job.takeOutput(),
+        exitCode: job.exitCode,
+        sessionId: job.id,
+        nextPollMs: job.nextPollMs,
+    };
+}
+function pruneJobs() {
+    const now = Date.now();
+    for (const [id, job] of jobs) {
+        if (job.status !== "running" && now - job.startedAt > 10 * 60 * 1000)
+            jobs.delete(id);
+    }
+    if (jobs.size > 50) {
+        const finished = Array.from(jobs.values())
+            .filter((job) => job.status !== "running")
+            .sort((a, b) => a.startedAt - b.startedAt);
+        for (const job of finished.slice(0, jobs.size - 50))
+            jobs.delete(job.id);
+    }
+}
+function shellQuote(value) {
+    return "'" + value.replace(/'/g, "'\\''") + "'";
+}
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/dist/agent/stream.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Streaming request runner with an idle timeout and prefix-safe retry.
+ *
+ * `provider.stream()` only exposes the caller's AbortSignal, so a connection
+ * that stalls after the headers arrive can wait forever. This wrapper adds:
+ *   • an idle timer reset on every chunk (default 60s),
+ *   • retries routed through `retryStream`, which skips the already delivered
+ *     prefix instead of duplicating tokens,
+ *   • `incomplete` detection so the chat loop can tell "server closed early"
+ *     from a normal finish.
+ */
+import type { ChatChunk, ChatRequest, Provider } from "../types.js";
+export interface RunStreamOptions {
+    signal?: AbortSignal;
+    idleTimeoutMs?: number;
+    maxRetries?: number;
+    onDelta?: (delta: string, text: string) => void;
+    onReset?: () => void;
+    clientRequestId?: string;
+    retryBackoffMs?: number[];
+}
+export interface RunStreamResult {
+    text: string;
+    usage?: ChatChunk["usage"];
+    toolCalls?: ChatChunk["toolCalls"];
+    incomplete: boolean;
+    retried: number;
+}
+export declare function runStream(provider: Provider, req: ChatRequest, apiKey: string | undefined, options?: RunStreamOptions): Promise<RunStreamResult>;

package/dist/agent/stream.js

@@ -0,0 +1,103 @@
+import { IncompleteStreamError, retryStream } from "../lib/net.js";
+export async function runStream(provider, req, apiKey, options = {}) {
+    const idleTimeoutMs = positive(options.idleTimeoutMs, 60_000);
+    const maxRetries = Math.max(0, Math.floor(options.maxRetries ?? 1));
+    let retried = 0;
+    let text = "";
+    let usage;
+    let toolCalls;
+    let sawDone = false;
+    const send = async function* ({ clientRequestId }) {
+        yield* attemptChunks(provider, { ...req, clientRequestId }, apiKey, {
+            signal: options.signal,
+            idleTimeoutMs,
+        });
+    };
+    try {
+        for await (const chunk of retryStream(send, {
+            clientRequestId: options.clientRequestId,
+            retries: maxRetries,
+            signal: options.signal,
+            backoffMs: options.retryBackoffMs,
+            onRetry: () => {
+                retried += 1;
+            },
+            onReset: options.onReset,
+        })) {
+            if (chunk.reset)
+                text = chunk.delta ?? "";
+            else if (chunk.delta)
+                text += chunk.delta;
+            if (chunk.delta)
+                options.onDelta?.(chunk.delta, text);
+            if (chunk.usage)
+                usage = chunk.usage;
+            if (chunk.toolCalls)
+                toolCalls = chunk.toolCalls;
+            if (chunk.done)
+                sawDone = true;
+        }
+    }
+    catch (err) {
+        if (err instanceof IncompleteStreamError) {
+            return { text: err.partialText || text, usage, toolCalls, incomplete: true, retried };
+        }
+        if (err && typeof err === "object" && !err.partialText && text)
+            err.partialText = text;
+        throw err;
+    }
+    return { text, usage, toolCalls, incomplete: !sawDone, retried };
+}
+async function* attemptChunks(provider, req, apiKey, options) {
+    const parent = options.signal;
+    const child = new AbortController();
+    let timedOut = false;
+    const forwardAbort = () => child.abort();
+    if (parent) {
+        if (parent.aborted)
+            child.abort();
+        else
+            parent.addEventListener("abort", forwardAbort, { once: true });
+    }
+    let timer;
+    const resetIdle = () => {
+        if (timer)
+            clearTimeout(timer);
+        timer = setTimeout(() => {
+            timedOut = true;
+            child.abort();
+        }, options.idleTimeoutMs);
+    };
+    resetIdle();
+    try {
+        for await (const chunk of provider.stream({ ...req, signal: child.signal }, apiKey)) {
+            resetIdle();
+            yield chunk;
+            if (chunk.done)
+                return;
+        }
+    }
+    catch (err) {
+        if (parent?.aborted)
+            throw abortError();
+        if (timedOut)
+            throw new Error(`stream idle timeout after ${options.idleTimeoutMs}ms (no data received)`);
+        throw toError(err);
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+        parent?.removeEventListener("abort", forwardAbort);
+    }
+}
+function abortError() {
+    const error = new Error("Aborted");
+    error.name = "AbortError";
+    return error;
+}
+function toError(value) {
+    return value instanceof Error ? value : new Error(String(value));
+}
+function positive(value, fallback) {
+    return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : fallback;
+}

package/dist/agent/tool-schemas.d.ts

@@ -0,0 +1,2 @@
+import type { ToolSchema } from "../types.js";
+export declare function toolSchemas(): ToolSchema[];

package/dist/agent/tool-schemas.js

@@ -0,0 +1,63 @@
+const CWD_NOTE = "Paths are relative to the session working directory unless absolute.";
+export function toolSchemas() {
+    return [
+        schema("shell", "Run a shell command. Long commands return a session id for polling.", {
+            command: { type: "string" },
+            timeoutMs: { type: "number" },
+            session_id: { type: "string", description: "Poll an existing background session." },
+            waitMs: { type: "number", description: "Milliseconds to wait for new session output." },
+        }),
+        schema("pwd", "Print the current working directory.", {}),
+        schema("read_file", CWD_NOTE, { path: { type: "string" } }, ["path"]),
+        schema("read_many", CWD_NOTE, { paths: { type: "array", items: { type: "string" } } }, ["paths"]),
+        schema("write_file", "Replace a file with full contents.", {
+            path: { type: "string" },
+            content: { type: "string" },
+        }, ["path", "content"]),
+        schema("append_file", "Append text to a file.", {
+            path: { type: "string" },
+            content: { type: "string" },
+        }, ["path", "content"]),
+        schema("apply_patch", "Apply a multi-file patch (*** Begin Patch ... *** End Patch).", {
+            patch: { type: "string" },
+        }, ["patch"]),
+        schema("copy_file", CWD_NOTE, { from: { type: "string" }, to: { type: "string" } }, ["from", "to"]),
+        schema("delete_file", "Delete a file or directory.", { path: { type: "string" } }, ["path"]),
+        schema("list_files", "List files under a directory.", {
+            path: { type: "string" },
+            maxDepth: { type: "number" },
+            detail: { type: "boolean" },
+        }),
+        schema("make_dir", "Create a directory.", { path: { type: "string" } }, ["path"]),
+        schema("move_path", "Move/rename a path; refuses an existing target.", {
+            from: { type: "string" },
+            to: { type: "string" },
+        }, ["from", "to"]),
+        schema("grep", "Search file contents with a regular expression.", {
+            pattern: { type: "string" },
+            path: { type: "string" },
+            maxDepth: { type: "number" },
+        }, ["pattern"]),
+        schema("replace_in_file", "Replace an exact text occurrence.", {
+            path: { type: "string" },
+            find: { type: "string" },
+            replace: { type: "string" },
+        }, ["path", "find", "replace"]),
+        schema("stat_path", "Show file metadata.", { path: { type: "string" } }, ["path"]),
+    ];
+}
+function schema(name, description, properties, required) {
+    return {
+        type: "function",
+        function: {
+            name,
+            description,
+            parameters: {
+                type: "object",
+                properties,
+                ...(required && required.length > 0 ? { required } : {}),
+                additionalProperties: false,
+            },
+        },
+    };
+}

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

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

package/dist/agent/tools/append_file.js

@@ -0,0 +1,26 @@
+import { appendFile, mkdir } from "node:fs/promises";
+import { dirname } from "node:path";
+import { resolvePath } from "./paths.js";
+import { invalid, preparePath, requiredString } from "./validate.js";
+export const appendFileTool = {
+    name: "append_file",
+    requiresTrust: true,
+    stateScope: "turn",
+    revalidate: ["trust", "sandboxRoots"],
+    prepare(call, ctx) {
+        try {
+            requiredString(call, "path");
+            requiredString(call, "content");
+        }
+        catch (err) {
+            return invalid(err.message);
+        }
+        return preparePath(ctx.cwd, requiredString(call, "path"));
+    },
+    async execute(call, ctx) {
+        const file = resolvePath(ctx.cwd, call);
+        await mkdir(dirname(file), { recursive: true });
+        await appendFile(file, requiredString(call, "content"), "utf8");
+        return { ok: true, output: `appended ${file}`, sideEffects: { touched: [file] } };
+    },
+};

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

@@ -0,0 +1,10 @@
+import type { Tool } from "./types.js";
+/**
+ * Atomic multi-file patch.
+ *
+ * Applies Add / Delete / Update / Move only after every file plan succeeds.
+ * Symbolic links are refused, CRLF and mode bits are preserved, and per-file
+ * diffs are returned. xattr / ACL are NOT preserved and the inode changes
+ * (tmp+rename); restart file watchers if they miss the change.
+ */
+export declare const applyPatchTool: Tool;

package/dist/agent/tools/apply_patch.js

@@ -0,0 +1,52 @@
+import { parsePatch } from "../../patch/parse.js";
+import { planPatch, reviewPatchPlan } from "../../patch/plan.js";
+import { applyPatchPlan } from "../../patch/apply.js";
+import { invalid, requiredString } from "./validate.js";
+/**
+ * Atomic multi-file patch.
+ *
+ * Applies Add / Delete / Update / Move only after every file plan succeeds.
+ * Symbolic links are refused, CRLF and mode bits are preserved, and per-file
+ * diffs are returned. xattr / ACL are NOT preserved and the inode changes
+ * (tmp+rename); restart file watchers if they miss the change.
+ */
+export const applyPatchTool = {
+    name: "apply_patch",
+    requiresTrust: true,
+    stateScope: "turn",
+    revalidate: ["trust", "sandboxRoots"],
+    approvalHints: { mayRequireApproval: true },
+    prepare(call) {
+        let patch;
+        try {
+            patch = requiredString(call, "patch");
+        }
+        catch (err) {
+            return invalid(err.message);
+        }
+        const parsed = parsePatch(patch);
+        return parsed.ok === false ? invalid(parsed.output) : { ok: true };
+    },
+    async execute(call, ctx) {
+        const patch = requiredString(call, "patch");
+        const planned = planPatch(patch, ctx.cwd);
+        if (planned.ok === false)
+            return { ok: false, output: planned.output };
+        const review = reviewPatchPlan(planned.plan);
+        if (review.kind === "deny")
+            return { ok: false, output: `patch denied: ${review.reason}` };
+        if (review.kind === "pending") {
+            return {
+                ok: false,
+                output: `patch needs approval (${review.reason}), but no approval resolver is registered; nothing was written.`,
+            };
+        }
+        const applied = applyPatchPlan(planned.plan);
+        const warnings = applied.warnings.length > 0 ? "\n\nwarnings:\n" + applied.warnings.map((line) => "- " + line).join("\n") : "";
+        return {
+            ok: applied.ok,
+            output: applied.output + warnings,
+            sideEffects: { touched: applied.touched, removed: applied.removed },
+        };
+    },
+};