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

package/dist/lib/diagnostics.js

@@ -5,18 +5,27 @@
  * diagnosed without opening the TUI: Node version, Termux detection, whether
  * stdout is a real terminal, the config root, and which provider keys exist.
  */
+import { existsSync, statSync } from "node:fs";
+import { totalmem, freemem, tmpdir as osTmpdir } from "node:os";
 import { detectPlatform, platformLabel } from "./platform.js";
 import { readPackageMeta } from "./pkg.js";
 import { shouldUseStableTerminalUi } from "./uiMode.js";
 import { getPaths } from "../config/paths.js";
-import { loadConfig, resolveApiKey, resolveProviderKey } from "../config/store.js";
+import { configCacheStatus, loadConfig, resolveApiKey, resolveProviderKey } from "../config/store.js";
+import { debugEnabled } from "./debug.js";
 import { PROVIDERS } from "../providers/index.js";
-import { listInstalledSkills } from "../skills/manager.js";
+import { listInstalledSkills, resolveRegistry } from "../skills/manager.js";
 import { listInstalledPlugins } from "../plugins/manager.js";
-import { loggingEnabled, listSessions, sessionCacheLimitBytes } from "../session/log.js";
+import { findUnclosedSessions, fsyncMode, loggingEnabled, listSessions, sessionCacheLimitBytes } from "../session/log.js";
 import { isTrusted } from "../config/trust.js";
-import { DEFAULT_DENY_PATTERNS } from "../agent/guards.js";
+import { DEFAULT_DENY_PATTERNS, loopExemptTools } from "../agent/guards.js";
 import { toolOutputLimit } from "../agent/limits.js";
+import { grepMaxBytes, readManyMaxBytes, readMaxBytes, readScanMaxBytes } from "../agent/tools/readers.js";
+import { normalizeEgressConfig } from "../agent/policy/egress.js";
+import { compactionConfigFromEnv, heapExceeded } from "../agent/compaction.js";
+import { shellPoolStats } from "../agent/shell-session.js";
+import { resolveToolProtocol, toolCapabilityKey } from "../agent/protocol-mode.js";
+import { getModelMeta, modelMetaOverridePath } from "./model-meta.js";
 const NODE_REQUIRED = "18.17";
 function readVersion() {
     return readPackageMeta().version;
@@ -28,6 +37,7 @@ function nodeIsSupported() {
 }
 export function collectDiagnostics() {
     const config = loadConfig();
+    const egress = normalizeEgressConfig(config.egress);
     let paths;
     try {
         paths = getPaths();
@@ -55,6 +65,16 @@ export function collectDiagnostics() {
         // Same for plugins.
     }
     const platform = detectPlatform();
+    const compaction = compactionConfigFromEnv();
+    const shells = shellPoolStats();
+    let authMode = "missing";
+    try {
+        if (paths?.auth && existsSync(paths.auth))
+            authMode = (statSync(paths.auth).mode & 0o777).toString(8).padStart(4, "0");
+    }
+    catch {
+        authMode = "unreadable";
+    }
     return {
         version: readVersion(),
         node: process.version,
@@ -69,17 +89,26 @@ export function collectDiagnostics() {
         configRoot: paths?.root,
         configFile: paths?.config,
         authFile: paths?.auth,
+        authMode,
+        tmpdir: process.env["TMPDIR"] || osTmpdir(),
+        memTotalMb: totalmem() / 1024 / 1024,
+        memFreeMb: freemem() / 1024 / 1024,
         providerId: config.providerId,
         model: config.model,
         keyPresent,
         keyStatus: provider ? keyLookup.status : "missing",
         keyEnv: provider?.authEnv?.[0],
         skillsInstalled,
+        skillsRegistry: resolveRegistry(process.env["FASTCODE_SKILLS_REGISTRY"], config.skillsRegistry),
+        debug: debugEnabled(),
+        configCache: configCacheStatus().cached,
         pluginsInstalled,
         enabledSkills: (config.enabledSkills ?? []).length,
         enabledPlugins: (config.enabledPlugins ?? []).length,
         sessionLogEnabled: loggingEnabled(),
         sessionCacheMb: Math.round(sessionCacheLimitBytes() / (1024 * 1024)),
+        sessionFsync: fsyncMode(),
+        unclosedSessions: findUnclosedSessions().length,
         sessionsDir: paths?.sessions,
         sessionsCount: listSessions().length,
         sessionsBytes: listSessions().reduce((sum, entry) => sum + entry.bytes, 0),
@@ -88,6 +117,41 @@ export function collectDiagnostics() {
         shellDenyPatterns: DEFAULT_DENY_PATTERNS.length,
         allowDangerous: ["1", "true", "yes", "on"].includes((process.env["FASTCODE_ALLOW_DANGEROUS"] ?? "").trim().toLowerCase()),
         toolOutputLimit: toolOutputLimit(),
+        readMaxBytes: readMaxBytes(),
+        readScanMaxBytes: readScanMaxBytes(),
+        readManyMaxBytes: readManyMaxBytes(),
+        grepMaxBytes: grepMaxBytes(),
+        egress: {
+            enabled: egress.enabled,
+            mode: egress.mode,
+            maxScanBytes: egress.maxScanBytes,
+            denyPaths: egress.denyPaths.length,
+            denyGlobs: egress.denyGlobs.length,
+            denyContentMarkers: egress.denyContentMarkers.length,
+            scanToolOutput: egress.scanToolOutput,
+        },
+        tokenBudget: positiveEnv("FASTCODE_TOKEN_BUDGET"),
+        costBudgetUsd: positiveEnv("FASTCODE_COST_BUDGET_USD"),
+        compactionEnabled: compaction.enabled,
+        compactionRatio: compaction.localThresholdRatio,
+        compactionKeepTurns: compaction.keepTurns,
+        compactionSummaryTokens: compaction.maxSummaryTokens,
+        compactionHeapMb: compaction.heapLimitMb,
+        compactionHeapUsedMb: process.memoryUsage().heapUsed / 1024 / 1024,
+        compactionForced: heapExceeded(compaction),
+        serverCompactionAware: compaction.serverCompactionAware,
+        shellActive: shells.active,
+        shellPool: shells.pool,
+        shellPoolMax: shells.maxPool,
+        shellSpawns: shells.spawns,
+        shellMaxSpawn: shells.maxSpawnPerTurn,
+        sseIdleMs: positiveEnv("FASTCODE_SSE_IDLE_MS") || 25_000,
+        toolProtocol: resolveToolProtocol(config, config.providerId, config.model),
+        toolProtocolMode: (process.env["FASTCODE_TOOL_PROTOCOL"] ?? "legacy").trim().toLowerCase(),
+        toolCapability: config.capabilities?.toolCalling?.[toolCapabilityKey(config.providerId, config.model)] ?? "unknown",
+        loopExempt: Array.from(loopExemptTools()),
+        modelMetaFile: modelMetaOverridePath(),
+        modelMeta: getModelMeta(config.providerId, config.model),
         providers: PROVIDERS.map((p) => ({
             id: p.id,
             label: p.label,
@@ -96,6 +160,10 @@ export function collectDiagnostics() {
         })),
     };
 }
+function positiveEnv(name) {
+    const value = Number(process.env[name]);
+    return Number.isFinite(value) && value > 0 ? value : 0;
+}
 export function formatDiagnostics(info) {
     const lines = [];
     lines.push(`FastCode ${info.version} — environment check`);
@@ -106,13 +174,25 @@ export function formatDiagnostics(info) {
     lines.push(`  stable UI     ${info.stableUi ? "on (anti-flicker)" : "off"}`);
     lines.push("  config root   " + (info.configRoot ?? "(unavailable)"));
     lines.push("  config file   " + (info.configFile ?? "(unavailable)"));
-    lines.push("  keys file     " + (info.authFile ?? "(unavailable)") + "   (separate, chmod 0600)");
+    lines.push("  keys file     " + (info.authFile ?? "(unavailable)") + "   mode " + info.authMode + (info.authMode !== "missing" && info.authMode !== "0600" ? "  [WARN: expected 0600]" : ""));
+    lines.push("  tmpdir        " + info.tmpdir + (info.termux && !String(info.tmpdir).startsWith("/data/data/com.termux") ? "  [WARN: use $PREFIX/tmp]" : ""));
+    lines.push("  memory        " + info.memFreeMb.toFixed(0) + "MB free / " + info.memTotalMb.toFixed(0) + "MB total");
     lines.push("  trusted cwd   " + (info.trusted ? "yes" : "NO - agent tools ask first or stay off") + "   (" + (info.trustFile ?? "?") + ")");
     lines.push("  session log   " + (info.sessionLogEnabled ? "on" : "off") + "   cache cap " + info.sessionCacheMb + "MB, " + info.sessionsCount + " file(s), " + (info.sessionsBytes / 1024 / 1024).toFixed(2) + "MB used");
-    lines.push("  session dir   " + (info.sessionsDir ?? "(unavailable)"));
-    lines.push("  shell guard   " + info.shellDenyPatterns + " deny patterns" + (info.allowDangerous ? "   [FASTCODE_ALLOW_DANGEROUS is ON]" : ""));
+    lines.push("  session fsync " + info.sessionFsync + "   unclosed " + info.unclosedSessions + "   " + (info.sessionsDir ?? "(unavailable)"));
+    lines.push("  shell guard   " + info.shellDenyPatterns + " legacy soft patterns" + (info.allowDangerous ? "   [FASTCODE_ALLOW_DANGEROUS is ON]" : ""));
     lines.push("  tool output   " + info.toolOutputLimit + " chars max (streaming cap)");
+    lines.push(`  read limits   read ${info.readMaxBytes}B · scan ${info.readScanMaxBytes}B · read_many ${info.readManyMaxBytes}B · grep ${info.grepMaxBytes}B`);
+    lines.push(`  egress        ${info.egress.enabled ? "enforce" : "audit-only"} · mode ${info.egress.mode} · scan ${info.egress.maxScanBytes}B · paths ${info.egress.denyPaths} · globs ${info.egress.denyGlobs} · markers ${info.egress.denyContentMarkers}`);
+    lines.push(`  budgets       ${info.tokenBudget > 0 ? "tokens ≤ " + info.tokenBudget : "token budget off"} · ${info.costBudgetUsd > 0 ? "$" + info.costBudgetUsd : "cost budget off"}`);
+    lines.push(`  compaction    ${info.compactionEnabled ? "on" : "off"} · ${Math.round(info.compactionRatio * 100)}% · keep ${info.compactionKeepTurns} turns · summary ${info.compactionSummaryTokens} tok · heap ${info.compactionHeapUsedMb.toFixed(1)}/${info.compactionHeapMb}MB${info.compactionForced ? " [FORCED]" : ""}${info.serverCompactionAware ? " · server-aware" : ""}`);
+    lines.push(`  shell pool    ${info.shellActive} active · ${info.shellPool}/${info.shellPoolMax} resident · ${info.shellSpawns} spawns · cap ${info.shellMaxSpawn}/turn`);
+    lines.push(`  loop exempt   ${info.loopExempt.length > 0 ? info.loopExempt.join(", ") : "(none)"}`);
+    lines.push(`  model meta    ctx ${info.modelMeta.contextWindow} · ~${info.modelMeta.charsPerToken} chars/token · ${info.modelMeta.supportsTools ? "tools" : "no tools"} · ${info.modelMetaFile}`);
+    lines.push(`  sse timeout   ${info.sseIdleMs}ms idle`);
+    lines.push(`  tool protocol ${info.toolProtocol} (${info.toolProtocolMode}) · cached ${info.toolCapability}`);
     lines.push(`  provider      ${info.providerId} · model ${info.model}`);
+    lines.push(`  config cache  ${info.configCache ? "warm" : "cold"} · debug ${info.debug ? "on" : "off"}`);
     let apiKeyStatus;
     if (info.keyPresent)
         apiKeyStatus = "present";
@@ -121,7 +201,7 @@ export function formatDiagnostics(info) {
     else
         apiKeyStatus = `MISSING — set ${info.keyEnv ?? "the provider env var"} or /login ${info.providerId} ${info.model} <key>`;
     lines.push(`  api key       ${apiKeyStatus}`);
-    lines.push(`  skills        ${info.skillsInstalled} installed, ${info.enabledSkills} enabled`);
+    lines.push(`  skills        ${info.skillsInstalled} installed, ${info.enabledSkills} enabled (${info.skillsRegistry || "no registry configured"})`);
     lines.push(`  plugins       ${info.pluginsInstalled} installed, ${info.enabledPlugins} enabled`);
     lines.push("");
     lines.push("  provider keys:");
@@ -134,6 +214,8 @@ export function formatDiagnostics(info) {
         lines.push("    - pkg install nodejs git");
         lines.push("    - keep the session alive with: termux-wake-lock");
         lines.push("    - add an extra-keys row for Esc/Ctrl in ~/.termux/termux.properties");
+        lines.push("    - long tasks: export TMPDIR=$PREFIX/tmp and use termux-wake-lock");
+        lines.push(`    - Android 12+ caps phantom processes (~32); background shells are pooled (${info.shellPool} resident, cap ${info.shellMaxSpawn}/turn)`);
     }
     return lines.join("\n");
 }

package/dist/lib/highlight-subset.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Trimmed highlight.js registry.
+ *
+ * cli-highlight imports the full `highlight.js` package, which registers every
+ * language and adds roughly a megabyte of language definitions to the bundle
+ * for a TUI that mostly renders JS/TS/JSON/sh/Python. The esbuild plugin in
+ * scripts/esbuild-plugins.mjs aliases the bare `highlight.js` import to this
+ * module so only the common set below is bundled.
+ *
+ * Unknown languages still work: cli-highlight throws, marked-terminal catches
+ * and renders the fence as plain styled text. `renderMarkdown` adds a short
+ * dimmed hint instead of failing or blanking the message.
+ */
+import hljs from "highlight.js/lib/core.js";
+export declare const COMMON_HIGHLIGHT_LANGUAGES: string[];
+export declare function supportsHighlightLanguage(language: string | undefined): boolean;
+export declare const highlight: any;
+export declare const highlightAuto: any;
+export declare const listLanguages: any;
+export declare const getLanguage: any;
+export default hljs;

package/dist/lib/highlight-subset.js

@@ -0,0 +1,88 @@
+/**
+ * Trimmed highlight.js registry.
+ *
+ * cli-highlight imports the full `highlight.js` package, which registers every
+ * language and adds roughly a megabyte of language definitions to the bundle
+ * for a TUI that mostly renders JS/TS/JSON/sh/Python. The esbuild plugin in
+ * scripts/esbuild-plugins.mjs aliases the bare `highlight.js` import to this
+ * module so only the common set below is bundled.
+ *
+ * Unknown languages still work: cli-highlight throws, marked-terminal catches
+ * and renders the fence as plain styled text. `renderMarkdown` adds a short
+ * dimmed hint instead of failing or blanking the message.
+ */
+import hljs from "highlight.js/lib/core.js";
+import javascript from "highlight.js/lib/languages/javascript.js";
+import typescript from "highlight.js/lib/languages/typescript.js";
+import json from "highlight.js/lib/languages/json.js";
+import bash from "highlight.js/lib/languages/bash.js";
+import python from "highlight.js/lib/languages/python.js";
+import go from "highlight.js/lib/languages/go.js";
+import rust from "highlight.js/lib/languages/rust.js";
+import java from "highlight.js/lib/languages/java.js";
+import c from "highlight.js/lib/languages/c.js";
+import cpp from "highlight.js/lib/languages/cpp.js";
+import csharp from "highlight.js/lib/languages/csharp.js";
+import css from "highlight.js/lib/languages/css.js";
+import xml from "highlight.js/lib/languages/xml.js";
+import yaml from "highlight.js/lib/languages/yaml.js";
+import markdown from "highlight.js/lib/languages/markdown.js";
+import sql from "highlight.js/lib/languages/sql.js";
+import diff from "highlight.js/lib/languages/diff.js";
+import dockerfile from "highlight.js/lib/languages/dockerfile.js";
+import powershell from "highlight.js/lib/languages/powershell.js";
+import kotlin from "highlight.js/lib/languages/kotlin.js";
+import swift from "highlight.js/lib/languages/swift.js";
+import ruby from "highlight.js/lib/languages/ruby.js";
+import php from "highlight.js/lib/languages/php.js";
+import lua from "highlight.js/lib/languages/lua.js";
+import r from "highlight.js/lib/languages/r.js";
+import scala from "highlight.js/lib/languages/scala.js";
+import ini from "highlight.js/lib/languages/ini.js";
+import makefile from "highlight.js/lib/languages/makefile.js";
+import plaintext from "highlight.js/lib/languages/plaintext.js";
+const LANGUAGES = {
+    javascript,
+    typescript,
+    json,
+    bash,
+    python,
+    go,
+    rust,
+    java,
+    c,
+    cpp,
+    csharp,
+    css,
+    xml,
+    yaml,
+    markdown,
+    sql,
+    diff,
+    dockerfile,
+    powershell,
+    kotlin,
+    swift,
+    ruby,
+    php,
+    lua,
+    r,
+    scala,
+    ini,
+    makefile,
+    plaintext,
+};
+for (const [name, definition] of Object.entries(LANGUAGES))
+    hljs.registerLanguage(name, definition);
+export const COMMON_HIGHLIGHT_LANGUAGES = Object.keys(LANGUAGES);
+export function supportsHighlightLanguage(language) {
+    if (!language)
+        return true;
+    const name = language.trim().toLowerCase().split(/\s+/)[0] ?? "";
+    return Boolean(name) && Boolean(hljs.getLanguage(name));
+}
+export const highlight = hljs.highlight.bind(hljs);
+export const highlightAuto = hljs.highlightAuto.bind(hljs);
+export const listLanguages = hljs.listLanguages.bind(hljs);
+export const getLanguage = hljs.getLanguage.bind(hljs);
+export default hljs;

package/dist/lib/http.d.ts

@@ -6,8 +6,18 @@
  * Anthropic's older streaming) handle their own parsing.
  */
 export declare function fetchJson(url: string, init?: any): Promise<any>;
+export declare class NetworkStallError extends Error {
+    readonly code = "NETWORK_STALL";
+    readonly bytesReceived: number;
+    constructor(message: string, bytesReceived?: number);
+}
+export interface StreamSseOptions {
+    idleTimeoutMs?: number;
+    totalTimeoutMs?: number;
+}
 /** Async iterator over SSE events from a streaming HTTP response. */
-export declare function streamSSE(res: any): AsyncGenerator<{
+export declare function streamSSE(res: any, options?: StreamSseOptions): AsyncGenerator<{
     event: any;
     data: string;
 }, void, unknown>;
+export declare function probeConnectivity(url: string, timeoutMs?: number): Promise<boolean>;

package/dist/lib/http.js

@@ -16,8 +16,17 @@ export async function fetchJson(url, init = {}) {
     }
     return (await res.json());
 }
+export class NetworkStallError extends Error {
+    code = "NETWORK_STALL";
+    bytesReceived;
+    constructor(message, bytesReceived = 0) {
+        super(message);
+        this.name = "NetworkStallError";
+        this.bytesReceived = bytesReceived;
+    }
+}
 /** Async iterator over SSE events from a streaming HTTP response. */
-export async function* streamSSE(res) {
+export async function* streamSSE(res, options = {}) {
     if (!res.ok) {
         const body = await res.text().catch(() => "");
         throw new Error(`${res.status} ${res.statusText}: ${body.slice(0, 500)}`);
@@ -26,19 +35,50 @@ export async function* streamSSE(res) {
         throw new Error("Empty response body");
     const reader = res.body.getReader();
     const decoder = new TextDecoder("utf-8");
+    const envIdle = Number(process.env["FASTCODE_SSE_IDLE_MS"]);
+    const idleMs = positive(options.idleTimeoutMs, positive(envIdle, 25_000));
+    const totalMs = positive(options.totalTimeoutMs, 0);
+    const startedAt = Date.now();
+    let bytesReceived = 0;
     let buffer = "";
     while (true) {
-        const { value, done } = await reader.read();
+        const remaining = totalMs > 0 ? totalMs - (Date.now() - startedAt) : Number.POSITIVE_INFINITY;
+        if (remaining <= 0)
+            throw new NetworkStallError(`SSE total timeout after ${totalMs}ms`, bytesReceived);
+        const boundedByTotal = remaining <= idleMs;
+        const waitMs = boundedByTotal ? Math.max(1, remaining) : idleMs;
+        let timer;
+        const timeout = new Promise((_resolve, reject) => {
+            timer = setTimeout(() => {
+                reject(new NetworkStallError(boundedByTotal
+                    ? `SSE total timeout after ${totalMs}ms`
+                    : `SSE idle timeout after ${idleMs}ms (no data received; set FASTCODE_SSE_IDLE_MS to wait longer)`, bytesReceived));
+            }, waitMs);
+        });
+        let chunk;
+        try {
+            chunk = await Promise.race([reader.read(), timeout]);
+        }
+        catch (err) {
+            await reader.cancel().catch(() => undefined);
+            throw err;
+        }
+        finally {
+            if (timer)
+                clearTimeout(timer);
+        }
+        const { value, done } = chunk;
         if (done)
             break;
+        bytesReceived += value?.byteLength ?? 0;
         // Normalize CR/LF so both "\n\n" and "\r\n\r\n" frame separators
         // are detected, including a CR/LF split across two chunks.
         buffer = (buffer + decoder.decode(value, { stream: true })).replace(/\r\n?/g, "\n");
         let sep = buffer.indexOf("\n\n");
         while (sep !== -1) {
-            const chunk = buffer.slice(0, sep);
+            const chunkText = buffer.slice(0, sep);
             buffer = buffer.slice(sep + 2);
-            const ev = parseSseChunk(chunk);
+            const ev = parseSseChunk(chunkText);
             if (ev)
                 yield ev;
             sep = buffer.indexOf("\n\n");
@@ -52,6 +92,24 @@ export async function* streamSSE(res) {
             yield ev;
     }
 }
+export async function probeConnectivity(url, timeoutMs = 3000) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), positive(timeoutMs, 3000));
+    try {
+        const res = await fetch(url, { signal: controller.signal });
+        await res.body?.cancel().catch(() => undefined);
+        return res.ok;
+    }
+    catch {
+        return false;
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+function positive(value, fallback) {
+    return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : fallback;
+}
 function parseSseChunk(chunk) {
     let event;
     const dataLines = [];

package/dist/lib/lifecycle.d.ts

@@ -0,0 +1,5 @@
+export declare function cleanupProcesses(): void;
+export interface ProcessGuardOptions {
+    onFatal?: (error: unknown) => void;
+}
+export declare function installProcessGuards(options?: ProcessGuardOptions): () => void;

package/dist/lib/lifecycle.js

@@ -0,0 +1,62 @@
+/**
+ * Process-level shutdown guards.
+ *
+ * The TUI already calls shutdownShells() from its React cleanup, but fatal
+ * errors and SIGTERM/SIGHUP can bypass that path. These guards are best-effort
+ * and idempotent; they do not turn FastCode into a kernel-level sandbox.
+ */
+import { shutdownShells } from "../agent/shell-session.js";
+let installed = false;
+let cleaned = false;
+export function cleanupProcesses() {
+    if (cleaned)
+        return;
+    cleaned = true;
+    try {
+        shutdownShells();
+    }
+    catch {
+        // Best effort: never mask the original failure.
+    }
+}
+export function installProcessGuards(options = {}) {
+    if (installed)
+        return () => undefined;
+    installed = true;
+    const onSignal = (signal) => {
+        process.stderr.write(`[fastcode] ${signal} received; shutting down.\n`);
+        cleanupProcesses();
+        process.exit(signal === "SIGINT" ? 130 : 143);
+    };
+    const onFatal = (error) => {
+        const detail = error instanceof Error ? (error.stack ?? error.message) : String(error);
+        process.stderr.write(`[fastcode] fatal: ${detail}\n`);
+        cleanupProcesses();
+        options.onFatal?.(error);
+        process.exit(1);
+    };
+    const signals = ["SIGTERM", "SIGHUP"];
+    for (const signal of signals) {
+        try {
+            process.on(signal, onSignal);
+        }
+        catch {
+            // Some platforms do not expose every signal.
+        }
+    }
+    process.on("uncaughtException", onFatal);
+    process.on("unhandledRejection", onFatal);
+    return () => {
+        for (const signal of signals) {
+            try {
+                process.removeListener(signal, onSignal);
+            }
+            catch {
+                // Ignore unsupported signals.
+            }
+        }
+        process.removeListener("uncaughtException", onFatal);
+        process.removeListener("unhandledRejection", onFatal);
+        installed = false;
+    };
+}

package/dist/lib/markdown.js

@@ -6,8 +6,10 @@
  * markdown parser. The result is a fully-formatted ANSI string we can
  * print directly inside an Ink <Text>.
  */
+import chalk from "chalk";
 import { marked } from "marked";
 import { markedTerminal } from "marked-terminal";
+import { supportsHighlightLanguage } from "./highlight-subset.js";
 let configured = false;
 function configure() {
     if (configured)
@@ -15,16 +17,32 @@ function configure() {
     marked.use(markedTerminal({
         reflowText: false,
         tab: 2,
+        // marked-terminal calls this only when highlighting fails; keep the
+        // cold-language fallback as plain text instead of colored source.
+        code: (text) => text,
     }));
     configured = true;
 }
+function unsupportedFenceLanguages(md) {
+    const missing = new Set();
+    for (const match of md.matchAll(/(?:^|\n)\s*(?:`{3,}|~{3,})([^\n]*)/g)) {
+        const info = (match[1] ?? "").trim();
+        if (!info)
+            continue;
+        const language = info.split(/\s+/)[0] ?? "";
+        if (language && !supportsHighlightLanguage(language))
+            missing.add(language);
+    }
+    return Array.from(missing);
+}
 export function renderMarkdown(md) {
     configure();
     try {
-        const out = marked.parse(md);
-        // marked-terminal sometimes appends a stray trailing newline; trim only
-        // trailing whitespace so we don't lose meaningful blank lines.
-        return out.replace(/\s+$/, "");
+        const out = marked.parse(md).replace(/\s+$/, "");
+        const missing = unsupportedFenceLanguages(String(md));
+        if (missing.length === 0)
+            return out;
+        return out + "\n\n" + chalk.dim(`[fastcode] no syntax highlighting for ${missing.join(", ")}; rendered as plain text.`);
     }
     catch {
         return md;

package/dist/lib/model-meta.d.ts

@@ -0,0 +1,19 @@
+export interface ModelMeta {
+    contextWindow: number;
+    supportsTools: boolean;
+    charsPerToken: number;
+    maxOutputTokens?: number;
+}
+export interface EstTokenOptions {
+    providerId?: string;
+    model?: string;
+    charsPerToken?: number;
+}
+export declare const UNKNOWN_MODEL_META: ModelMeta;
+export declare function modelMetaOverridePath(): string;
+export declare function clearModelMetaCache(): void;
+export declare function getModelMeta(providerId?: string, model?: string): ModelMeta;
+export declare function estTokens(text: string, options?: number | EstTokenOptions): number;
+export declare function estMessagesTokens(messages: Array<{
+    content: string;
+}>, options?: EstTokenOptions): number;

package/dist/lib/model-meta.js

@@ -0,0 +1,113 @@
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+export const UNKNOWN_MODEL_META = {
+    contextWindow: 32_768,
+    supportsTools: false,
+    charsPerToken: 2.5,
+};
+const PROVIDER_META = {
+    anthropic: { contextWindow: 1_000_000, supportsTools: true, charsPerToken: 3.8, maxOutputTokens: 64_000 },
+    openai: { contextWindow: 400_000, supportsTools: true, charsPerToken: 3.8, maxOutputTokens: 32_000 },
+    google: { contextWindow: 1_048_576, supportsTools: true, charsPerToken: 3.6, maxOutputTokens: 65_536 },
+    deepseek: { contextWindow: 128_000, supportsTools: true, charsPerToken: 1.7, maxOutputTokens: 8_192 },
+    openrouter: { contextWindow: 128_000, supportsTools: true, charsPerToken: 2.5, maxOutputTokens: 16_384 },
+    groq: { contextWindow: 128_000, supportsTools: true, charsPerToken: 3.8, maxOutputTokens: 8_192 },
+    mistral: { contextWindow: 128_000, supportsTools: true, charsPerToken: 3.8, maxOutputTokens: 8_192 },
+    xai: { contextWindow: 256_000, supportsTools: true, charsPerToken: 3.8, maxOutputTokens: 16_384 },
+    moonshot: { contextWindow: 256_000, supportsTools: true, charsPerToken: 2.0, maxOutputTokens: 16_384 },
+    zhipu: { contextWindow: 128_000, supportsTools: true, charsPerToken: 1.7, maxOutputTokens: 8_192 },
+    qwen: { contextWindow: 128_000, supportsTools: true, charsPerToken: 1.7, maxOutputTokens: 8_192 },
+    ollama: { contextWindow: 32_768, supportsTools: true, charsPerToken: 2.5, maxOutputTokens: 4_096 },
+    custom: { contextWindow: 32_768, supportsTools: false, charsPerToken: 2.5 },
+};
+const MODEL_OVERRIDES = {
+    "claude-haiku-5.5": { contextWindow: 200_000 },
+    "claude-haiku-4.5": { contextWindow: 200_000 },
+    "claude-sonnet-5": { contextWindow: 1_000_000 },
+    "claude-opus-5": { contextWindow: 1_000_000 },
+    "claude-sonnet-4.6": { contextWindow: 1_000_000 },
+    "claude-opus-4.6": { contextWindow: 1_000_000 },
+    "gpt-4o": { contextWindow: 128_000 },
+    "gpt-4o-mini": { contextWindow: 128_000 },
+    "gpt-4.1": { contextWindow: 1_000_000 },
+    o3: { contextWindow: 200_000 },
+    "o4-mini": { contextWindow: 200_000 },
+    "gemini-3.5-flash-lite": { contextWindow: 1_048_576 },
+    "gemini-3.1-flash-lite": { contextWindow: 1_048_576 },
+    "deepseek-v4-pro": { contextWindow: 128_000, charsPerToken: 1.7 },
+    "deepseek-flash": { contextWindow: 128_000, charsPerToken: 1.7 },
+    "glm-5.3": { contextWindow: 128_000, charsPerToken: 1.7 },
+    "glm-5.2": { contextWindow: 128_000, charsPerToken: 1.7 },
+    "qwen3.8-max": { contextWindow: 128_000, charsPerToken: 1.7 },
+    "qwen3.8-flash": { contextWindow: 128_000, charsPerToken: 1.7 },
+    "kimi-k3": { contextWindow: 256_000, charsPerToken: 2.0 },
+    "grok-4.7": { contextWindow: 256_000, charsPerToken: 3.8 },
+    "mistral-large-latest": { contextWindow: 128_000, charsPerToken: 3.8 },
+};
+let overrideCache;
+export function modelMetaOverridePath() {
+    const root = process.env["FASTCODE_HOME"] ?? join(homedir(), ".fastcode");
+    return join(root, "model-meta.json");
+}
+export function clearModelMetaCache() {
+    overrideCache = undefined;
+}
+function loadOverrides() {
+    if (overrideCache)
+        return overrideCache;
+    const file = modelMetaOverridePath();
+    if (!existsSync(file)) {
+        overrideCache = {};
+        return overrideCache;
+    }
+    try {
+        const raw = JSON.parse(readFileSync(file, "utf8"));
+        overrideCache = raw && typeof raw === "object" && !Array.isArray(raw) ? raw : {};
+    }
+    catch {
+        overrideCache = {};
+    }
+    return overrideCache;
+}
+function usable(meta) {
+    return Boolean(meta) && typeof meta === "object";
+}
+function apply(base, ...layers) {
+    const next = { ...base };
+    for (const layer of layers) {
+        if (!usable(layer))
+            continue;
+        if (typeof layer.contextWindow === "number" && layer.contextWindow > 0)
+            next.contextWindow = Math.floor(layer.contextWindow);
+        if (typeof layer.charsPerToken === "number" && layer.charsPerToken > 0)
+            next.charsPerToken = layer.charsPerToken;
+        if (typeof layer.supportsTools === "boolean")
+            next.supportsTools = layer.supportsTools;
+        if (typeof layer.maxOutputTokens === "number" && layer.maxOutputTokens > 0)
+            next.maxOutputTokens = Math.floor(layer.maxOutputTokens);
+    }
+    return next;
+}
+export function getModelMeta(providerId, model) {
+    const provider = providerId && PROVIDER_META[providerId] ? PROVIDER_META[providerId] : UNKNOWN_MODEL_META;
+    const overrides = loadOverrides();
+    const keys = [
+        providerId && model ? `${providerId}/${model}` : undefined,
+        providerId && model ? `${providerId}::${model}` : undefined,
+        model,
+    ].filter((key) => Boolean(key));
+    const layers = keys.map((key) => overrides[key]);
+    return apply(provider, model ? MODEL_OVERRIDES[model] : undefined, ...layers);
+}
+export function estTokens(text, options = {}) {
+    if (!text)
+        return 0;
+    const ratio = typeof options === "number"
+        ? options
+        : options.charsPerToken ?? getModelMeta(options.providerId, options.model).charsPerToken;
+    return Math.ceil(text.length / Math.max(0.1, ratio));
+}
+export function estMessagesTokens(messages, options = {}) {
+    return messages.reduce((sum, message) => sum + estTokens(message.content ?? "", options), 0);
+}