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

package/LICENSE

@@ -1,6 +1,10 @@
 MIT License
 
 Copyright (c) 2026 SimpleLittleDev
+Copyright (c) 2026 FastCode-Termux contributors
+
+This project is a fix and Termux adaptation based on SimpleLittleDev/FastCode,
+originally licensed under MIT.
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -16,16 +16,24 @@
 </p>
 
 ```bash
-npm install -g @datename/fastcode-termux
+npm install -g @datename/fastcode-termux@0.1.8-beta.0
 fastcode
 ```
 
+> Registry check (2026-11-09): npm still reports `latest=0.1.6` / `beta=0.1.6-beta`. If `@0.1.8-beta.0` is not resolvable yet, use the repo/portable build or `@0.1.6-beta`.
+
 Short alias included:
 
 ```bash
 fc
 ```
 
+This tree is **0.1.8-beta.0**, based on tag `v0.1.7` plus the 2026-11-09
+fixes (shell safety, `/threads`, exit protection, approval feedback,
+compaction/projection, TUI effort, license). It is built and packaged locally
+but not published. The npm registry still reports `latest=0.1.6` /
+`beta=0.1.6-beta` (checked 2026-11-09); `release/` contains 0.1.8-beta.0 assets.
+
 ---
 
 ## 🌈 What Is FastCode?
@@ -80,7 +88,7 @@ npm link
 ### Global install
 
 ```bash
-npm install -g @datename/fastcode-termux
+npm install -g @datename/fastcode-termux@0.1.8-beta.0
 fastcode
 ```
 
@@ -108,7 +116,7 @@ export OPENAI_API_KEY="sk-..."
 export OPENROUTER_API_KEY="sk-or-..."
 ```
 
-Or bind a key from inside FastCode — scoped to a specific provider + model (input is masked):
+Or bind a key from inside FastCode — one key per provider, reused by all its models (input is masked):
 
 ```text
 /login                                        # guided: provider → model → key
@@ -133,7 +141,7 @@ fastcode
 | `google` | `gemini-1.5-flash` | `GEMINI_API_KEY` or `GOOGLE_API_KEY` |
 | `openrouter` | `anthropic/claude-3.5-sonnet` | `OPENROUTER_API_KEY` |
 | `groq` | `llama-3.3-70b-versatile` | `GROQ_API_KEY` |
-| `deepseek` | `deepseek-chat` | `DEEPSEEK_API_KEY` |
+| `deepseek` | `deepseek-flash` | `DEEPSEEK_API_KEY` |
 | `mistral` | `mistral-small-latest` | `MISTRAL_API_KEY` |
 | `ollama` | `llama3.2` | Local, no API key required |
 
@@ -237,8 +245,29 @@ Installed plugins live under:
 
 ---
 
+## ⌨️ CLI Commands
+
+These subcommands do not start a conversation:
+
+| Command | Action |
+| --- | --- |
+| `fastcode` / `fastcode "prompt"` | open TUI / open with an initial prompt |
+| `fastcode --version` / `-v` / `--help` / `-h` | version / all commands |
+| `fastcode provider [id]` / `model [id]` | list or set default provider / model |
+| `fastcode config` / `config path` | config + paths / config.json path only |
+| `fastcode sessions` / `sessions show <id>` / `resume [id\|latest]` | list / inspect / resume sessions |
+| `fastcode trust [dir]` / `untrust [dir]` / `trusted` / `trust --forget <key>` | trust management |
+| `fastcode skills list\|install <id>\|uninstall <id>\|search <q>` | skill management |
+| `fastcode doctor` / `doctor --net` | diagnostics / probe registry |
+| `fastcode update` | check for updates |
+| `--ui tty\|native\|plain\|json` | approval/render backend |
+
+---
+
 ## 🎮 Slash Commands
 
+These run in the TUI without sending a model request:
+
 | Command | Action |
 | --- | --- |
 | `/help` | Show command list |
@@ -246,26 +275,36 @@ Installed plugins live under:
 | `/tools` | Show available coding tools |
 | `/cwd` | Show agent sandbox root |
 | `/plugin ...` | Import and manage always-active plugin packs |
-| `/provider [id]` | List or switch provider |
-| `/model [id]` | List or switch model |
-| `/login [provider] [model] [key]` | Bind an API key to a provider + model (guided when omitted) |
-| `/logout <provider> [model]` | Remove a scoped key (`--all` for the whole provider) |
+| `/provider [id]` | Pick or switch provider (interactive when omitted) |
+| `/model [id]` | Pick or switch model (interactive when omitted) |
+| `/effort [level]` | Thinking effort: auto / low / medium / high / max |
+| `/login [provider] [model] [key]` | Bind a provider-wide API key (guided when omitted) |
+| `/logout <provider>` | Remove the provider's key (`--all` accepted for compatibility) |
 | `/skills ...` | Search, install, enable, disable, list skills |
 | `/theme [id]` | Switch theme |
 | `/cost` | Show token and cost usage |
 | `/system [text]` | Show or update system prompt |
 | `/whoami` | Show configured provider keys |
 | `/config` | Print config and paths |
-| `/clear` | Clear conversation |
+| `/clear` (`cls`) | Clear conversation |
 | `/reset` | Reset config |
 | `/about` | Show version and platform |
-| `/exit` | Quit |
+| `/context` | Token estimate, compaction threshold, heap |
+| `/compact` | Force local context compaction |
+| `/cancel` | Abort the active run (mobile alternative to Esc) |
+| `/steer <text>` | Guide the next request of an active run |
+| `/jobs` / `/attach <id>` / `/kill <id>` | Background shell sessions |
+| `/threads [1-6]` | Show or set resident shell concurrency (default 2, max 6) |
+| `/expand` | Toggle full/collapsed tool output |
+| `/edit` | Edit the prompt in `$EDITOR` (works around Ink IME bugs) |
+| `/bg` | Explain background shell behaviour |
+| `/exit` | Abort the active run, kill resident shells, then quit |
 
 Keyboard controls:
 
 ```text
-Esc       cancel streaming
-Ctrl+C    press twice to quit
+Esc       cancel streaming; partial output is kept
+Ctrl+C    during a run: first cancels, second quits; idle: press twice to quit
 ```
 
 ---
@@ -296,10 +335,12 @@ Install Node.js first:
 
 ```bash
 pkg install nodejs
-npm install -g @datename/fastcode-termux
+npm install -g @datename/fastcode-termux@0.1.8-beta.0
 fastcode
 ```
 
+> If npm does not resolve `@0.1.8-beta.0` yet, install the portable bundle or use `@0.1.6-beta`.
+
 If the command is not found, check your npm global binary path:
 
 ```bash
@@ -381,14 +422,22 @@ npm publish --access public
 
 ---
 
-## Safety, sessions and limits (0.1.6)
+## Safety, sessions and limits (0.1.8-beta.0)
 
 | Feature | Behaviour | Override |
 | --- | --- | --- |
 | Project trust | First run in a folder asks before agent tools load; the list lives in ~/.fastcode/trusted.json | fastcode trust / untrust / trusted, FASTCODE_TRUST_ALL=1 |
-| Dangerous-command guard | rm -rf, del /f, rmdir /s, format / mkfs / diskpart, dd if=, writes to /dev/sd, shutdown / reboot / poweroff and fork bombs are refused before execution | FASTCODE_ALLOW_DANGEROUS=1, FASTCODE_SHELL_ALLOWLIST, FASTCODE_SHELL_DENY_EXTRA |
+| Dangerous-command guard | Hard Block for destructive/system/sensitive-file commands and credential exfil; `.env` writes/deletes/moves, critical credential reads and egress are non-overridable | FASTCODE_ALLOW_DANGEROUS=1 only for Soft Gate |
+| Egress policy | application-layer tool/payload/output policy; default audit-only, `enabled:true + mode:"block"` returns `EGRESS_DENY` | `config.egress`: enabled, mode, denyPaths, denyGlobs, denyContentMarkers, maxScanBytes |
 | Unified tool-output cap | Output is truncated while it is produced, not sliced afterwards (default 30000 characters) | FASTCODE_TOOL_OUTPUT_LIMIT |
 | Session log | Append-only JSONL in ~/.fastcode/sessions, resumable after a crash (cache cap 256MB by default) | fastcode sessions, fastcode resume, FASTCODE_SESSION_LOG=0, FASTCODE_SESSION_CACHE_MB |
+| Checkpoints/projection | `*.projection.json` (~200KB cap) with tool/model/cwd fingerprint; tool payloads folded to edit facts, dropped-message markers, summary markers protected; unpaired tool calls completed on resume | FASTCODE_FSYNC, FASTCODE_SESSION_LOG |
+| Exit save point | `/exit` aborts the run, stops shells, then writes `session_end{reason,compaction}` + projection and best-effort fsyncs both; busy runs require a second `/exit` within 5s; Esc/Ctrl+C keep partial output | `/exit` (`/quit`, `/q`), double Ctrl+C |
+| Patch transaction | parse → plan → apply; CRLF/mode kept; symlinks refused; move never overwrites | `/expand` for the full diff |
+| Process tree | abort or `/kill` kills children/grandchildren; `/exit` uses SIGTERM → wait → SIGKILL for resident shells | POSIX process group, Windows `taskkill /T` |
+| Compaction | token/heap threshold; Notes/Outcomes/Files first; summary written to `summary-*.md`; `/compact` records a `compacted` fact; old summaries cleaned | FASTCODE_COMPACTION=0, FASTCODE_COMPACTION_RATIO, FASTCODE_COMPACTION_KEEP_TURNS, FASTCODE_COMPACTION_SUMMARY_TOKENS, FASTCODE_HEAP_LIMIT_MB |
+| Background shell | Commands over ~2s return a session id; poll incrementally. `/threads` caps the **resident** pool (default 2, max 6); one-shot commands use a separate `FASTCODE_MAX_SPAWN_PER_TURN` budget and are not globally capped | `/jobs`, `/attach`, `/kill`, `/threads`, FASTCODE_MAX_SPAWN_PER_TURN |
+| Approval hook | Sensitive/large patches need approval; without a resolver they are denied (fail closed) | pending UI not implemented yet |
 
 ## 🙏 Credits
 
@@ -398,4 +447,6 @@ npm publish --access public
 
 ## 📜 License
 
-MIT © SimpleLittleDev
+MIT. Original FastCode © 2026 SimpleLittleDev; this fix/Termux adaptation © 2026
+FastCode-Termux contributors. Based on `SimpleLittleDev/FastCode`
+(`@simplelittledev/fastcode` 0.1.3), originally MIT. See `LICENSE`.

package/dist/agent/approval-json.d.ts

@@ -0,0 +1,43 @@
+/**
+ * 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, ApprovalRequest } from "./approval.js";
+export declare 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;
+}
+export declare function encodeGateAsk(request: ApprovalRequest): GateAskEvent;
+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 declare function parseGateDecision(request: ApprovalRequest, line: string): GateDecisionResult;

package/dist/agent/approval-json.js

@@ -0,0 +1,69 @@
+import { decisionForOption } from "./approval.js";
+export const GATE_PROTOCOL_VERSION = 1;
+function optionId(option, index) {
+    return option.id ?? `${option.kind}-${index}`;
+}
+function targetsFor(request) {
+    const args = request.args ?? {};
+    const values = [args.path, args.from, args.to, args.cwd, request.preview?.kind === "diff" ? "diff" : undefined];
+    return values.filter((value) => typeof value === "string" && value.length > 0);
+}
+export function encodeGateAsk(request) {
+    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 } : {}),
+    };
+}
+/**
+ * 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, line) {
+    let payload;
+    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/dist/agent/approval-native.d.ts

@@ -0,0 +1,3 @@
+import { type ApprovalDecision, type ApprovalRequest } from "./approval.js";
+export declare function nativeDecisionFromPayload(request: ApprovalRequest, payload: any): ApprovalDecision | undefined;
+export declare function nativeApproval(request: ApprovalRequest, signal?: AbortSignal): Promise<ApprovalDecision | undefined>;

package/dist/agent/approval-native.js

@@ -0,0 +1,165 @@
+/**
+ * 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 } from "./approval.js";
+export function nativeDecisionFromPayload(request, payload) {
+    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, signal, timeoutMs = 60_000) {
+    if (signal?.aborted)
+        return undefined;
+    return await new Promise((resolve) => {
+        let settled = false;
+        let child;
+        let timer;
+        const finish = (value) => {
+            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) => {
+            stdout += chunk;
+        });
+        child.on("error", () => finish(undefined));
+        child.on("close", () => {
+            let payload;
+            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, signal) {
+    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;
+        let timer;
+        const finish = (value) => {
+            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) => {
+            stdout += chunk;
+        });
+        child.on("error", () => finish(undefined));
+        child.on("close", async () => {
+            let payload;
+            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/dist/agent/approval-store.d.ts

@@ -0,0 +1,16 @@
+/**
+ * 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";
+export declare function approvalKey(tool: string, call: ToolCall, cwd: string): string;
+export declare function isPreApproved(key: string, catalogHash: string): boolean;
+export declare function rememberApproval(key: string, catalogHash: string, scope: ApprovalScope): void;
+export declare function clearSessionApprovals(): void;

package/dist/agent/approval-store.js

@@ -0,0 +1,21 @@
+import { toolCallFingerprint } from "./guards.js";
+import { isToolApproved, rememberToolApproval } from "../config/trust.js";
+const sessionApprovals = new Set();
+export function approvalKey(tool, call, cwd) {
+    return `${tool}:${toolCallFingerprint(call, cwd)}`;
+}
+export function isPreApproved(key, catalogHash) {
+    return sessionApprovals.has(`${catalogHash}:${key}`) || isToolApproved(key, catalogHash);
+}
+export function rememberApproval(key, catalogHash, scope) {
+    if (scope === "once")
+        return;
+    if (scope === "session") {
+        sessionApprovals.add(`${catalogHash}:${key}`);
+        return;
+    }
+    rememberToolApproval(key, catalogHash);
+}
+export function clearSessionApprovals() {
+    sessionApprovals.clear();
+}

package/dist/agent/approval.d.ts

@@ -0,0 +1,83 @@
+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 declare const DEFAULT_ALLOW_OPTIONS: ApprovalOption[];
+export declare function approvalRequestId(): string;
+export declare function approvalOptionForDecision(request: ApprovalRequest, decision: ApprovalDecision): ApprovalOption | undefined;
+export declare function parseApprovalChoice(request: ApprovalRequest, text: string): ApprovalOption | undefined;
+export declare function decisionForOption(option: ApprovalOption, input?: string): ApprovalDecision;

package/dist/agent/approval.js

@@ -0,0 +1,42 @@
+export const DEFAULT_ALLOW_OPTIONS = [
+    { 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() {
+    return "ap_" + Date.now().toString(36) + "_" + Math.random().toString(36).slice(2, 7);
+}
+export function approvalOptionForDecision(request, decision) {
+    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, text) {
+    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, input) {
+    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" };
+}