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

package/src/config/trust.ts

@@ -7,11 +7,30 @@
  *
  * FASTCODE_TRUST_ALL=1 marks every directory trusted (scripts, CI).
  */
-import { existsSync, readFileSync, realpathSync, writeFileSync } from "node:fs";
+import { existsSync, readFileSync, realpathSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { resolve } from "node:path";
 import { ensureDir, getPaths } from "./paths.js";
+
 const TRUTHY = ["1", "true", "yes", "on"];
-export function normalizeProjectPath(dir) {
+
+export interface TrustPathEntry {
+    grantedAt: string;
+    lastUsed: string;
+}
+
+export interface TrustToolEntry extends TrustPathEntry {
+    catalogHash: string;
+}
+
+export interface TrustStore {
+    version: 1;
+    tools: Record<string, TrustToolEntry>;
+    paths: Record<string, TrustPathEntry>;
+}
+
+let cache: { file: string; key: string; state: TrustStore } | undefined;
+
+export function normalizeProjectPath(dir: string): string {
     const absolute = resolve(dir);
     try {
         return realpathSync(absolute);
@@ -20,48 +39,188 @@ export function normalizeProjectPath(dir) {
         return absolute;
     }
 }
-export function loadTrust() {
+
+function emptyStore(): TrustStore {
+    return { version: 1, tools: {}, paths: {} };
+}
+
+function normalizePaths(raw: any): Record<string, TrustPathEntry> {
+    const paths: Record<string, TrustPathEntry> = {};
+    if (!raw || typeof raw !== "object")
+        return paths;
+    for (const [key, value] of Object.entries<any>(raw)) {
+        if (!key || !value || typeof value !== "object")
+            continue;
+        paths[key] = {
+            grantedAt: typeof value.grantedAt === "string" ? value.grantedAt : "",
+            lastUsed: typeof value.lastUsed === "string" ? value.lastUsed : "",
+        };
+    }
+    return paths;
+}
+
+function normalizeTools(raw: any): Record<string, TrustToolEntry> {
+    const tools: Record<string, TrustToolEntry> = {};
+    if (!raw || typeof raw !== "object")
+        return tools;
+    for (const [key, value] of Object.entries<any>(raw)) {
+        if (!key || !value || typeof value !== "object" || typeof value.catalogHash !== "string")
+            continue;
+        tools[key] = {
+            grantedAt: typeof value.grantedAt === "string" ? value.grantedAt : "",
+            lastUsed: typeof value.lastUsed === "string" ? value.lastUsed : "",
+            catalogHash: value.catalogHash,
+        };
+    }
+    return tools;
+}
+
+function migrateLegacy(raw: any): TrustStore | undefined {
+    if (!raw || typeof raw !== "object" || !Array.isArray(raw.trusted))
+        return undefined;
+    const store = emptyStore();
+    for (const entry of raw.trusted) {
+        if (!entry || typeof entry.path !== "string" || !entry.path)
+            continue;
+        const at = typeof entry.addedAt === "string" ? entry.addedAt : new Date().toISOString();
+        store.paths[entry.path] = { grantedAt: at, lastUsed: at };
+    }
+    return store;
+}
+
+function readStore(file: string): TrustStore {
+    if (!existsSync(file))
+        return emptyStore();
+    try {
+        const raw = JSON.parse(readFileSync(file, "utf8"));
+        if (raw && raw.version === 1) {
+            return {
+                version: 1,
+                tools: normalizeTools(raw.tools),
+                paths: normalizePaths(raw.paths),
+            };
+        }
+        const migrated = migrateLegacy(raw);
+        if (!migrated)
+            return emptyStore();
+        try {
+            writeFileSync(file, JSON.stringify(migrated, null, 2), "utf8");
+        }
+        catch {
+            // A read-only home still gets the migrated view in memory.
+        }
+        return migrated;
+    }
+    catch {
+        return emptyStore();
+    }
+}
+
+export function loadTrust(): TrustStore {
     const { trust } = getPaths();
-    if (!existsSync(trust))
-        return { trusted: [] };
+    let key = "missing";
     try {
-        const raw = JSON.parse(readFileSync(trust, "utf8"));
-        return { trusted: Array.isArray(raw.trusted) ? raw.trusted.filter((entry) => entry && typeof entry.path === "string") : [] };
+        const info = statSync(trust);
+        key = `${info.mtimeMs}:${info.size}`;
     }
     catch {
-        return { trusted: [] };
+        // Missing file: cache the empty store until it appears.
     }
+    if (cache && cache.file === trust && cache.key === key)
+        return cache.state;
+    const state = readStore(trust);
+    cache = { file: trust, key, state };
+    return state;
 }
-function saveTrust(state) {
+
+function saveTrust(state: TrustStore): void {
     const paths = getPaths();
     ensureDir(paths.root);
-    writeFileSync(paths.trust, JSON.stringify(state, null, 2), "utf8");
+    const tmp = paths.trust + "." + process.pid + ".tmp";
+    try {
+        writeFileSync(tmp, JSON.stringify(state, null, 2), "utf8");
+        renameSync(tmp, paths.trust);
+    }
+    catch (err) {
+        try {
+            rmSync(tmp, { force: true });
+        }
+        catch {
+            // best effort
+        }
+        throw err;
+    }
+    try {
+        const info = statSync(paths.trust);
+        cache = { file: paths.trust, key: `${info.mtimeMs}:${info.size}`, state };
+    }
+    catch {
+        cache = undefined;
+    }
 }
-export function trustAllEnabled() {
+
+export function trustAllEnabled(): boolean {
     return TRUTHY.includes((process.env["FASTCODE_TRUST_ALL"] ?? "").trim().toLowerCase());
 }
-export function isTrusted(dir) {
+
+export function isTrusted(dir: string): boolean {
     if (trustAllEnabled())
         return true;
     const target = normalizeProjectPath(dir);
-    return loadTrust().trusted.some((entry) => entry.path === target);
+    return Boolean(loadTrust().paths[target]);
 }
-export function trustProject(dir) {
+
+export function trustProject(dir: string): string {
     const target = normalizeProjectPath(dir);
     const state = loadTrust();
-    if (!state.trusted.some((entry) => entry.path === target)) {
-        state.trusted.push({ path: target, addedAt: new Date().toISOString() });
+    if (!state.paths[target]) {
+        const at = new Date().toISOString();
+        state.paths[target] = { grantedAt: at, lastUsed: at };
         saveTrust(state);
     }
     return target;
 }
-export function untrustProject(dir) {
+
+export function untrustProject(dir: string): boolean {
     const target = normalizeProjectPath(dir);
     const state = loadTrust();
-    const next = state.trusted.filter((entry) => entry.path !== target);
-    saveTrust({ trusted: next });
-    return state.trusted.length !== next.length;
+    if (!state.paths[target])
+        return false;
+    delete state.paths[target];
+    saveTrust(state);
+    return true;
+}
+
+export function listTrusted(): Array<{ path: string; addedAt: string }> {
+    return Object.entries(loadTrust().paths).map(([path, entry]) => ({ path, addedAt: entry.grantedAt }));
+}
+
+/** Check a tool/fingerprint approval bound to the current tool catalog. */
+export function isToolApproved(key: string, catalogHash: string): boolean {
+    const entry = loadTrust().tools[key];
+    return Boolean(entry && entry.catalogHash === catalogHash);
+}
+
+export function rememberToolApproval(key: string, catalogHash: string): void {
+    const state = loadTrust();
+    const at = new Date().toISOString();
+    state.tools[key] = { grantedAt: at, lastUsed: at, catalogHash };
+    saveTrust(state);
+}
+
+export function forgetToolApproval(key: string): boolean {
+    const state = loadTrust();
+    if (!state.tools[key])
+        return false;
+    delete state.tools[key];
+    saveTrust(state);
+    return true;
 }
-export function listTrusted() {
-    return loadTrust().trusted;
+
+export function listToolApprovals(): Array<{ key: string; grantedAt: string; catalogHash: string }> {
+    return Object.entries(loadTrust().tools).map(([key, entry]) => ({
+        key,
+        grantedAt: entry.grantedAt,
+        catalogHash: entry.catalogHash,
+    }));
 }

package/src/headless.ts

@@ -0,0 +1,225 @@
+/**
+ * Non-Ink headless runner for `--ui json` / non-TTY `--ui plain`.
+ *
+ * stdout is reserved for the protocol/answer; diagnostics go to stderr.
+ */
+import readline from "node:readline";
+import { AGENT_SYSTEM_PROMPT } from "./agent/protocol.js";
+import { compactionConfigFromEnv } from "./agent/compaction.js";
+import { resolveToolProtocol } from "./agent/protocol-mode.js";
+import { runAgent } from "./agent/runner.js";
+import { setShellPoolSize } from "./agent/shell-session.js";
+import { toolSchemas } from "./agent/tool-schemas.js";
+import { encodeGateAsk, parseGateDecision } from "./agent/approval-json.js";
+import { decisionForOption, parseApprovalChoice, type ApprovalDecision, type ApprovalRequest } from "./agent/approval.js";
+import { buildPluginsPrompt } from "./plugins/manager.js";
+import { buildSkillsPrompt } from "./skills/manager.js";
+import { loadConfig, resolveApiKey } from "./config/store.js";
+import { getProviderOrThrow } from "./providers/index.js";
+import { resumeSession } from "./session/projection.js";
+
+interface HeadlessOptions {
+    prompt: string;
+    ui: "json" | "plain";
+    resume?: string;
+}
+
+let eventSeq = 0;
+
+function writeEvent(value: Record<string, any>): void {
+    eventSeq += 1;
+    process.stdout.write(JSON.stringify({ v: 1, seq: eventSeq, ts: new Date().toISOString(), ...value }) + "\n");
+}
+
+function optionalBudget(name: string): number | undefined {
+    const value = Number(process.env[name]);
+    return Number.isFinite(value) && value > 0 ? value : undefined;
+}
+
+export async function runHeadless(options: HeadlessOptions): Promise<void> {
+    const config = loadConfig();
+    setShellPoolSize(config.shellPoolSize);
+    const provider = getProviderOrThrow(config.providerId);
+    let apiKey: string | undefined;
+    if (provider.authEnv.length > 0) {
+        const lookup = resolveApiKey(provider.id, config.model, provider.authEnv);
+        if (lookup.status !== "ok")
+            throw new Error(`No usable API key for ${provider.id}.`);
+        apiKey = lookup.key;
+    }
+    const history = options.resume ? resumeSession(options.resume, process.cwd()).messages : [];
+    const system = [
+        config.systemPrompt,
+        buildSkillsPrompt(config.enabledSkills),
+        buildPluginsPrompt(config.enabledPlugins),
+        config.agentMode ? AGENT_SYSTEM_PROMPT : "",
+    ].filter((part) => part.trim()).join("\n\n");
+    const protocol = config.agentMode ? resolveToolProtocol(config, config.providerId, config.model) : "legacy";
+    const rl = readline.createInterface({ input: process.stdin, crlfDelay: Infinity });
+    const queued: string[] = [];
+    const waiters: Array<(line: string | undefined) => void> = [];
+    let eof = false;
+    rl.on("line", (line) => {
+        const waiter = waiters.shift();
+        if (waiter)
+            waiter(line);
+        else
+            queued.push(line);
+    });
+    rl.on("close", () => {
+        eof = true;
+        while (waiters.length > 0)
+            waiters.shift()!(undefined);
+    });
+    const nextLine = (timeoutMs: number): Promise<string | undefined> => {
+        if (queued.length > 0)
+            return Promise.resolve(queued.shift());
+        if (eof)
+            return Promise.resolve(undefined);
+        return new Promise((resolve) => {
+            const waiter = (line: string | undefined) => {
+                clearTimeout(timer);
+                resolve(line);
+            };
+            const timer = setTimeout(() => {
+                const index = waiters.indexOf(waiter);
+                if (index >= 0)
+                    waiters.splice(index, 1);
+                resolve(undefined);
+            }, Math.max(1000, timeoutMs));
+            timer.unref?.();
+            waiters.push(waiter);
+        });
+    };
+
+    const requestApproval = async (request: ApprovalRequest): Promise<ApprovalDecision> => {
+        if (options.ui === "json") {
+            writeEvent(encodeGateAsk(request));
+            const line = await nextLine(request.timeoutMs ?? 60_000);
+            if (line === undefined)
+                return { kind: "deny", reason: "approval timeout/EOF" };
+            const parsed = parseGateDecision(request, line);
+            if (parsed.error) {
+                writeEvent({ event: "gate:error", version: 1, id: request.id, error: parsed.error });
+                return parsed.decision;
+            }
+            return parsed.decision;
+        }
+        process.stderr.write(`${request.prompt ?? "Approval required"}\n`);
+        request.options.forEach((option, index) => process.stderr.write(`${index + 1}. ${option.label}\n`));
+        process.stderr.write(`Choose 1-${request.options.length}: `);
+        const line = await nextLine(request.timeoutMs ?? 60_000);
+        const option = line === undefined ? undefined : parseApprovalChoice(request, line);
+        if (!option)
+            return { kind: "deny", reason: "approval cancelled/invalid/timeout" };
+        if (option.kind === "feedback") {
+            process.stderr.write(`${option.prompt || "Why should this be denied?"}\n> `);
+            const feedbackLine = await nextLine(request.timeoutMs ?? 60_000);
+            const feedback = feedbackLine?.trim();
+            return feedback
+                ? { kind: "feedback", text: feedback }
+                : { kind: "deny", reason: "feedback cancelled/empty (fail closed)" };
+        }
+        return decisionForOption(option);
+    };
+
+    const abort = new AbortController();
+    const onSigint = () => abort.abort();
+    const onTerminate = () => abort.abort();
+    process.once("SIGINT", onSigint);
+    process.once("SIGTERM", onTerminate);
+    process.once("SIGHUP", onTerminate);
+    try {
+        for await (const event of runAgent({
+            provider,
+            apiKey,
+            model: config.model,
+            messages: history,
+            prompt: options.prompt,
+            system,
+            maxTurns: config.agentMode ? Math.max(1, Math.floor(Number(config.maxAgentTurns) || 24)) : 1,
+            allowTools: config.agentMode,
+            tokenBudget: optionalBudget("FASTCODE_TOKEN_BUDGET"),
+            costBudgetUsd: optionalBudget("FASTCODE_COST_BUDGET_USD"),
+            signal: abort.signal,
+            cwd: process.cwd(),
+            idleTimeoutMs: config.requestIdleTimeoutMs,
+            compaction: compactionConfigFromEnv(),
+            reasoningEffort: config.reasoningEffort,
+            protocol,
+            tools: protocol === "native" ? toolSchemas() : undefined,
+            requestApproval,
+        })) {
+            if (options.ui === "json") {
+                if (event.type === "assistant_text")
+                    writeEvent({ event: "assistant", text: event.text });
+                else if (event.type === "tool_call")
+                    writeEvent({
+                        event: "tool_call",
+                        id: event.id,
+                        tool: event.call.tool,
+                        args: event.call,
+                        ...(event.native ? { native: true } : {}),
+                    });
+                else if (event.type === "egress_denied")
+                    writeEvent({
+                        event: "egress_denied",
+                        outlet: event.outlet,
+                        ...(event.target ? { target: event.target } : {}),
+                        rule: event.rule,
+                        mode: event.mode,
+                        would_block: event.wouldBlock,
+                        code: event.code,
+                        reason: event.reason,
+                    });
+                else if (event.type === "tool_result")
+                    writeEvent({
+                        event: "tool_result",
+                        id: event.id,
+                        tool: event.call.tool,
+                        ok: event.ok,
+                        output: event.output,
+                        ...(event.sideEffects ? { side_effects: event.sideEffects } : {}),
+                        ...(event.code ? { code: event.code } : {}),
+                        ...(event.hint ? { hint: event.hint } : {}),
+                        ...(event.truncated !== undefined ? { truncated: event.truncated } : {}),
+                        ...(event.totalLines !== undefined ? { total_lines: event.totalLines } : {}),
+                        ...(event.returnedLines !== undefined ? { returned_lines: event.returnedLines } : {}),
+                        ...(event.totalBytes !== undefined ? { total_bytes: event.totalBytes } : {}),
+                        ...(event.returnedBytes !== undefined ? { returned_bytes: event.returnedBytes } : {}),
+                        ...(event.filesRead !== undefined ? { files_read: event.filesRead } : {}),
+                        ...(event.filesSkipped !== undefined ? { files_skipped: event.filesSkipped } : {}),
+                        ...(event.matches !== undefined ? { matches: event.matches } : {}),
+                    });
+                else if (event.type === "usage")
+                    writeEvent({
+                        event: "usage",
+                        input_tokens: event.usage.inputTokens ?? 0,
+                        output_tokens: event.usage.outputTokens ?? 0,
+                        cost_usd: event.usage.costUsd ?? 0,
+                    });
+                else if (event.type === "notice")
+                    writeEvent({ event: "notice", text: event.text });
+                else if (event.type === "error")
+                    writeEvent({ event: "error", kind: event.kind, code: event.kind, message: event.message });
+                else if (event.type === "done")
+                    writeEvent({ event: "done", stopReason: event.stopReason, finalText: event.finalText });
+            }
+            else if (event.type === "assistant_text") {
+                process.stdout.write(event.text);
+            }
+            else if (event.type === "notice") {
+                process.stderr.write(`[fastcode] ${event.text}\n`);
+            }
+            else if (event.type === "done" && event.finalText) {
+                process.stdout.write(event.finalText + "\n");
+            }
+        }
+    }
+    finally {
+        process.removeListener("SIGINT", onSigint);
+        process.removeListener("SIGTERM", onTerminate);
+        process.removeListener("SIGHUP", onTerminate);
+        rl.close();
+    }
+}

package/src/index.ts

@@ -5,13 +5,29 @@
  * Ink-based TUI. We keep this file tiny so the slow imports (Ink, React)
  * are not loaded for `fastcode skills list`.
  */
-import { parseCli } from "./cli.js";
+import { parseCli } from "./cli-main.js";
+import { installProcessGuards } from "./lib/lifecycle.js";
 async function main() {
+    installProcessGuards();
     const cli = await parseCli();
     if (cli.done)
         return;
+    if (cli.ui === "json") {
+        if (!cli.prompt) {
+            console.error("--ui json requires a prompt: fastcode --ui json \"<prompt>\"");
+            process.exit(1);
+        }
+        const { runHeadless } = await import("./headless.js");
+        await runHeadless({ prompt: cli.prompt, ui: "json", resume: cli.resume });
+        return;
+    }
     if (!process.stdout.isTTY) {
-        console.error("FastCode TUI requires a TTY. Pipe-mode prompts aren't supported yet — try `fastcode \"<prompt>\"` from a real terminal.");
+        if (cli.ui === "plain" && cli.prompt) {
+            const { runHeadless } = await import("./headless.js");
+            await runHeadless({ prompt: cli.prompt, ui: "plain", resume: cli.resume });
+            return;
+        }
+        console.error("FastCode TUI requires a TTY. Use `fastcode --ui plain|json \"<prompt>\"` for pipe mode.");
         process.exit(1);
     }
     // Lazy-load Ink so subcommands don't pay the React boot cost.
@@ -23,7 +39,7 @@ async function main() {
     // React.createElement avoids needing a separate .tsx loader for this file.
     // exitOnCtrlC: false lets the app own Ctrl+C so the documented
     // "press Ctrl+C twice to quit" behavior actually works.
-    render(React.createElement(App, { initialPrompt: cli.prompt, resume: cli.resume }), { exitOnCtrlC: false });
+    render(React.createElement(App, { initialPrompt: cli.prompt, resume: cli.resume, ui: cli.ui ?? "tty" }), { exitOnCtrlC: false });
 }
 main().catch((err) => {
     console.error(err);

package/src/lib/debug.ts

@@ -0,0 +1,24 @@
+/**
+ * Minimal debug logging.
+ *
+ * There is no logging framework in this project: normal output goes through
+ * Ink and lifecycle warnings go straight to stderr. `FASTCODE_DEBUG=1` opts
+ * into low-volume stderr diagnostics (for example timeout clamping or config
+ * cache invalidation) without changing the default experience.
+ */
+const TRUTHY = new Set(["1", "true", "yes", "on"]);
+
+export function debugEnabled(): boolean {
+    return TRUTHY.has((process.env["FASTCODE_DEBUG"] ?? "").trim().toLowerCase());
+}
+
+export function debugLog(scope: string, message: string): void {
+    if (!debugEnabled())
+        return;
+    try {
+        process.stderr.write(`[fastcode:${scope}] ${message}\n`);
+    }
+    catch {
+        // Debug logging must never break the operation it observes.
+    }
+}