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

package/src/agent/approval-json.ts

@@ -0,0 +1,103 @@
+/**
+ * Stable NDJSON gate protocol for GUI/JSON clients.
+ *
+ * This module is pure: it validates and encodes one request/decision at a
+ * time. A headless transport can consume it without leaking TUI output to
+ * stdout. Hard Block requests never reach this code.
+ */
+import type { ApprovalDecision, ApprovalOption, ApprovalRequest } from "./approval.js";
+import { decisionForOption } from "./approval.js";
+
+export const GATE_PROTOCOL_VERSION = 1;
+
+export interface GateAskEvent {
+    event: "gate:ask";
+    version: number;
+    id: string;
+    tier: number;
+    action: string;
+    reason: string;
+    prompt: string;
+    source: string;
+    targets: string[];
+    diffstat: { files: number; lines: number };
+    options: Array<{ id: string; label: string; kind: string; default?: boolean }>;
+    default: string;
+    require_input?: string;
+}
+
+function optionId(option: ApprovalOption, index: number): string {
+    return option.id ?? `${option.kind}-${index}`;
+}
+
+function targetsFor(request: ApprovalRequest): string[] {
+    const args: any = request.args ?? {};
+    const values = [args.path, args.from, args.to, args.cwd, request.preview?.kind === "diff" ? "diff" : undefined];
+    return values.filter((value): value is string => typeof value === "string" && value.length > 0);
+}
+
+export function encodeGateAsk(request: ApprovalRequest): GateAskEvent {
+    const options = request.options.map((option, index) => ({
+        id: optionId(option, index),
+        label: option.label,
+        kind: option.kind,
+        ...(index === (request.defaultIndex ?? 0) ? { default: true } : {}),
+    }));
+    const defaultIndex = Math.max(0, Math.min(request.defaultIndex ?? 0, options.length - 1));
+    const text = request.preview?.kind === "diff" ? request.preview.text : "";
+    const feedbackOption = request.options.find((option) => option.kind === "feedback");
+    const requireInput = request.freeInput?.prompt ?? feedbackOption?.prompt;
+    return {
+        event: "gate:ask",
+        version: GATE_PROTOCOL_VERSION,
+        id: request.id,
+        tier: request.tier ?? 2,
+        action: request.tool,
+        reason: request.reason,
+        prompt: request.prompt ?? "Approval required",
+        source: request.source ?? "system",
+        targets: targetsFor(request),
+        diffstat: { files: text ? text.split(/\r?\n/).filter(Boolean).length : 0, lines: text ? text.split(/\r?\n/).length : 0 },
+        options,
+        default: options[defaultIndex]?.id ?? "",
+        ...(requireInput ? { require_input: requireInput } : {}),
+    };
+}
+
+export interface GateDecisionResult {
+    decision: ApprovalDecision;
+    error?: string;
+}
+
+/**
+ * Accept only a well-formed decision for this exact request id and one of its
+ * stable option ids. Malformed JSON, wrong ids, unknown options and missing
+ * required input all fail closed.
+ */
+export function parseGateDecision(request: ApprovalRequest, line: string): GateDecisionResult {
+    let payload: any;
+    try {
+        payload = JSON.parse(line);
+    }
+    catch {
+        return { decision: { kind: "deny", reason: "malformed JSON decision" }, error: "malformed JSON" };
+    }
+    if (!payload || typeof payload !== "object" || payload.version !== GATE_PROTOCOL_VERSION)
+        return { decision: { kind: "deny", reason: "unsupported gate protocol version" }, error: "version" };
+    if (payload.event !== "gate:decision")
+        return { decision: { kind: "deny", reason: "unexpected gate event" }, error: "event" };
+    if (payload.id !== request.id)
+        return { decision: { kind: "deny", reason: "decision id does not match the pending request" }, error: "id" };
+    if (request.freeInput?.enabled && (typeof payload.input !== "string" || payload.input.trim() === ""))
+        return { decision: { kind: "deny", reason: "required free input is missing" }, error: "input" };
+    const option = request.options.find((entry, index) => optionId(entry, index) === payload.option);
+    if (!option)
+        return { decision: { kind: "deny", reason: "unknown approval option id" }, error: "option" };
+    if (option.kind === "feedback") {
+        const text = typeof payload.input === "string" ? payload.input.trim() : "";
+        if (!text)
+            return { decision: { kind: "deny", reason: "feedback input is required" }, error: "feedback" };
+        return { decision: { kind: "feedback", text } };
+    }
+    return { decision: decisionForOption(option) };
+}

package/src/agent/approval-native.ts

@@ -0,0 +1,168 @@
+/**
+ * Termux:API approval sheet.
+ *
+ * Returns undefined when termux-dialog is missing/times out/crashes so the
+ * caller can fall back to the TUI. A real cancellation returns a deny.
+ * The command is built with spawn args (no shell interpolation).
+ */
+import { spawn } from "node:child_process";
+import { decisionForOption, type ApprovalDecision, type ApprovalRequest } from "./approval.js";
+
+export function nativeDecisionFromPayload(request: ApprovalRequest, payload: any): ApprovalDecision | undefined {
+    if (payload?.code === -1)
+        return { kind: "deny", reason: "termux-dialog cancelled" };
+    if (payload?.code !== 0 || !Number.isInteger(payload.index) ||
+        payload.index < 0 || payload.index >= request.options.length)
+        return { kind: "deny", reason: "termux-dialog returned an invalid selection" };
+    return decisionForOption(request.options[payload.index]);
+}
+
+async function nativeFeedback(prompt: string, signal?: AbortSignal, timeoutMs = 60_000): Promise<string | undefined> {
+    if (signal?.aborted)
+        return undefined;
+    return await new Promise((resolve) => {
+        let settled = false;
+        let child: ReturnType<typeof spawn> | undefined;
+        let timer: ReturnType<typeof setTimeout> | undefined;
+        const finish = (value: string | undefined) => {
+            if (settled)
+                return;
+            settled = true;
+            if (timer)
+                clearTimeout(timer);
+            signal?.removeEventListener("abort", onAbort);
+            resolve(value);
+        };
+        const onAbort = () => {
+            try {
+                child?.kill("SIGKILL");
+            }
+            catch {
+                // Already gone.
+            }
+            finish(undefined);
+        };
+        signal?.addEventListener("abort", onAbort, { once: true });
+        child = spawn("termux-dialog", ["text", "-t", prompt], {
+            stdio: ["ignore", "pipe", "ignore"],
+            windowsHide: true,
+        });
+        let stdout = "";
+        child.stdout?.setEncoding("utf8");
+        child.stdout?.on("data", (chunk: string) => {
+            stdout += chunk;
+        });
+        child.on("error", () => finish(undefined));
+        child.on("close", () => {
+            let payload: any;
+            try {
+                payload = JSON.parse(stdout.trim());
+            }
+            catch {
+                finish(undefined);
+                return;
+            }
+            if (payload?.code === 0 && typeof payload.text === "string")
+                finish(payload.text);
+            else
+                finish(undefined);
+        });
+        timer = setTimeout(() => {
+            try {
+                child?.kill("SIGKILL");
+            }
+            catch {
+                // Already gone.
+            }
+            finish(undefined);
+        }, Math.max(1000, timeoutMs));
+        timer.unref?.();
+    });
+}
+
+export async function nativeApproval(request: ApprovalRequest, signal?: AbortSignal): Promise<ApprovalDecision | undefined> {
+    if (signal?.aborted)
+        return { kind: "deny", reason: "approval cancelled" };
+    const labels = request.options.map((option) => option.label);
+    const title = request.prompt ?? `Approval: ${request.tool}`;
+    return await new Promise((resolve) => {
+        let settled = false;
+        let child: ReturnType<typeof spawn> | undefined;
+        let timer: ReturnType<typeof setTimeout> | undefined;
+        const finish = (value: ApprovalDecision | undefined) => {
+            if (settled)
+                return;
+            settled = true;
+            if (timer)
+                clearTimeout(timer);
+            signal?.removeEventListener("abort", onAbort);
+            resolve(value);
+        };
+        const onAbort = () => {
+            try {
+                child?.kill("SIGKILL");
+            }
+            catch {
+                // Already gone.
+            }
+            finish({ kind: "deny", reason: "approval cancelled" });
+        };
+        signal?.addEventListener("abort", onAbort, { once: true });
+        child = spawn("termux-dialog", ["sheet", "-v", labels.join(","), "-t", title], {
+            stdio: ["ignore", "pipe", "ignore"],
+            windowsHide: true,
+        });
+        let stdout = "";
+        child.stdout?.setEncoding("utf8");
+        child.stdout?.on("data", (chunk: string) => {
+            stdout += chunk;
+        });
+        child.on("error", () => finish(undefined));
+        child.on("close", async () => {
+            let payload: any;
+            try {
+                payload = JSON.parse(stdout.trim());
+            }
+            catch {
+                finish(undefined);
+                return;
+            }
+            const selected = payload?.code === 0 && Number.isInteger(payload.index)
+                ? request.options[payload.index]
+                : undefined;
+            if (selected?.kind === "feedback") {
+                if (timer) {
+                    clearTimeout(timer);
+                    timer = undefined;
+                }
+                const prompt = selected.prompt || "Why should this be denied?";
+                const text = await nativeFeedback(prompt, signal, request.timeoutMs);
+                if (signal?.aborted) {
+                    finish({ kind: "deny", reason: "approval cancelled" });
+                    return;
+                }
+                if (typeof text !== "string") {
+                    // Text dialog unavailable/cancelled: fall back to the TUI prompt.
+                    finish(undefined);
+                    return;
+                }
+                const feedback = text.trim();
+                finish(feedback
+                    ? { kind: "feedback", text: feedback }
+                    : { kind: "deny", reason: "feedback was empty (fail closed)" });
+                return;
+            }
+            finish(nativeDecisionFromPayload(request, payload));
+        });
+        timer = setTimeout(() => {
+            try {
+                child?.kill("SIGKILL");
+            }
+            catch {
+                // Already gone.
+            }
+            finish(undefined);
+        }, Math.max(1000, request.timeoutMs ?? 60_000));
+        timer.unref?.();
+    });
+}

package/src/agent/approval-store.ts

@@ -0,0 +1,38 @@
+/**
+ * Approval scope storage.
+ *
+ * - once: no persistence
+ * - session: in-memory, implicitly cleared when the process exits
+ * - always: ~/.fastcode/trusted.json `tools` entry bound to catalogHash
+ *
+ * Keys include the normalized tool-call fingerprint so "always" cannot grant
+ * every future shell command from one approval.
+ */
+import type { ApprovalScope } from "./approval.js";
+import type { ToolCall } from "./tools/types.js";
+import { toolCallFingerprint } from "./guards.js";
+import { isToolApproved, rememberToolApproval } from "../config/trust.js";
+
+const sessionApprovals = new Set<string>();
+
+export function approvalKey(tool: string, call: ToolCall, cwd: string): string {
+    return `${tool}:${toolCallFingerprint(call, cwd)}`;
+}
+
+export function isPreApproved(key: string, catalogHash: string): boolean {
+    return sessionApprovals.has(`${catalogHash}:${key}`) || isToolApproved(key, catalogHash);
+}
+
+export function rememberApproval(key: string, catalogHash: string, scope: ApprovalScope): void {
+    if (scope === "once")
+        return;
+    if (scope === "session") {
+        sessionApprovals.add(`${catalogHash}:${key}`);
+        return;
+    }
+    rememberToolApproval(key, catalogHash);
+}
+
+export function clearSessionApprovals(): void {
+    sessionApprovals.clear();
+}

package/src/agent/approval.ts

@@ -0,0 +1,94 @@
+export type ApprovalScope = "once" | "session" | "always";
+
+export type ApprovalReason =
+  | "trust"
+  | "sensitive_path"
+  | "ambiguous_match"
+  | "destructive"
+  | "large_diff";
+
+export interface ChoiceItem {
+  label: string;
+  value: string;
+}
+
+export type ApprovalPreview =
+  | { kind: "diff"; text: string }
+  | { kind: "choices"; items: ChoiceItem[] };
+
+export type ApprovalOption =
+  | { kind: "allow"; id?: string; scope: ApprovalScope; label: string }
+  | { kind: "deny"; id?: string; label: string }
+  | { kind: "choose"; id?: string; label: string; value: string; meta?: { recommended?: boolean; risk?: string; files?: number; reason?: string } }
+  | { kind: "feedback"; id?: string; label: string; prompt: string };
+
+export interface ApprovalRequest {
+  id: string;
+  tool: string;
+  args: unknown;
+  reason: ApprovalReason;
+  options: ApprovalOption[];
+  preview?: ApprovalPreview;
+  tier?: 0 | 1 | 2 | 3;
+  prompt?: string;
+  source?: "system" | "ai" | "free";
+  defaultIndex?: number;
+  timeoutMs?: number;
+  freeInput?: { enabled: true; prompt: string; hint?: string };
+}
+
+export type ApprovalDecision =
+  | { kind: "allow"; scope: ApprovalScope }
+  | { kind: "deny"; reason?: string; feedback?: string; code?: string; target?: string }
+  | { kind: "pending"; request: ApprovalRequest }
+  | { kind: "choose"; value: string; input?: string }
+  | { kind: "feedback"; text: string };
+
+export type ApprovalResolver = (request: ApprovalRequest) => ApprovalDecision | Promise<ApprovalDecision>;
+
+export const DEFAULT_ALLOW_OPTIONS: ApprovalOption[] = [
+  { kind: "allow", id: "allow-once", scope: "once", label: "Allow once" },
+  { kind: "allow", id: "allow-session", scope: "session", label: "Allow for this session" },
+  { kind: "allow", id: "allow-always", scope: "always", label: "Always allow" },
+  { kind: "deny", id: "deny", label: "Deny" },
+  { kind: "feedback", id: "feedback", label: "Deny with feedback", prompt: "Why should this be denied?" },
+];
+
+export function approvalRequestId(): string {
+  return "ap_" + Date.now().toString(36) + "_" + Math.random().toString(36).slice(2, 7);
+}
+
+export function approvalOptionForDecision(request: ApprovalRequest, decision: ApprovalDecision): ApprovalOption | undefined {
+  if (decision.kind === "allow")
+    return request.options.find((option) => option.kind === "allow" && option.scope === decision.scope);
+  if (decision.kind === "deny")
+    return request.options.find((option) => option.kind === "deny");
+  if (decision.kind === "choose")
+    return request.options.find((option) => option.kind === "choose" && option.value === decision.value);
+  if (decision.kind === "feedback")
+    return request.options.find((option) => option.kind === "feedback");
+  return undefined;
+}
+
+export function parseApprovalChoice(request: ApprovalRequest, text: string): ApprovalOption | undefined {
+    const index = Number(String(text ?? "").trim()) - 1;
+    if (!Number.isInteger(index) || index < 0 || index >= request.options.length)
+        return undefined;
+    return request.options[index];
+}
+
+export function decisionForOption(option: ApprovalOption, input?: string): ApprovalDecision {
+  if (option.kind === "allow")
+    return { kind: "allow", scope: option.scope };
+  if (option.kind === "choose")
+    return { kind: "choose", value: option.value };
+  if (option.kind === "feedback") {
+    const text = typeof input === "string" ? input.trim() : "";
+    // The option's prompt is the question, not the user's answer. Without an
+    // actual answer, fail closed instead of sending the prompt back to the model.
+    return text
+      ? { kind: "feedback", text }
+      : { kind: "deny", reason: "feedback was required but not provided (fail closed)" };
+  }
+  return { kind: "deny", reason: "denied by user" };
+}