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

package/dist/config/trust.js

@@ -0,0 +1,153 @@
+/**
+ * Project trust store.
+ *
+ * Agent tools can read, write, delete and execute inside the workspace, so a
+ * folder is only enabled after the user confirms it once. The list lives in
+ * ~/.fastcode/trusted.json and is compared by real path.
+ *
+ * FASTCODE_TRUST_ALL=1 marks every directory trusted (scripts, CI).
+ */
+import { existsSync, readFileSync, realpathSync, statSync, writeFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { ensureDir, getPaths } from "./paths.js";
+const TRUTHY = ["1", "true", "yes", "on"];
+let cache;
+export function normalizeProjectPath(dir) {
+    const absolute = resolve(dir);
+    try {
+        return realpathSync(absolute);
+    }
+    catch {
+        return absolute;
+    }
+}
+function emptyStore() {
+    return { version: 1, tools: {}, paths: {} };
+}
+function normalizePaths(raw) {
+    const paths = {};
+    if (!raw || typeof raw !== "object")
+        return paths;
+    for (const [key, value] of Object.entries(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) {
+    const tools = {};
+    if (!raw || typeof raw !== "object")
+        return tools;
+    for (const [key, value] of Object.entries(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) {
+    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) {
+    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() {
+    const { trust } = getPaths();
+    let key = "missing";
+    try {
+        const info = statSync(trust);
+        key = `${info.mtimeMs}:${info.size}`;
+    }
+    catch {
+        // 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) {
+    const paths = getPaths();
+    ensureDir(paths.root);
+    writeFileSync(paths.trust, JSON.stringify(state, null, 2), "utf8");
+    try {
+        const info = statSync(paths.trust);
+        cache = { file: paths.trust, key: `${info.mtimeMs}:${info.size}`, state };
+    }
+    catch {
+        cache = undefined;
+    }
+}
+export function trustAllEnabled() {
+    return TRUTHY.includes((process.env["FASTCODE_TRUST_ALL"] ?? "").trim().toLowerCase());
+}
+export function isTrusted(dir) {
+    if (trustAllEnabled())
+        return true;
+    const target = normalizeProjectPath(dir);
+    return Boolean(loadTrust().paths[target]);
+}
+export function trustProject(dir) {
+    const target = normalizeProjectPath(dir);
+    const state = loadTrust();
+    if (!state.paths[target]) {
+        const at = new Date().toISOString();
+        state.paths[target] = { grantedAt: at, lastUsed: at };
+        saveTrust(state);
+    }
+    return target;
+}
+export function untrustProject(dir) {
+    const target = normalizeProjectPath(dir);
+    const state = loadTrust();
+    if (!state.paths[target])
+        return false;
+    delete state.paths[target];
+    saveTrust(state);
+    return true;
+}
+export function listTrusted() {
+    return Object.entries(loadTrust().paths).map(([path, entry]) => ({ path, addedAt: entry.grantedAt }));
+}

package/dist/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/index.js

@@ -0,0 +1,31 @@
+/**
+ * FastCode entrypoint.
+ *
+ * Parses CLI args, then either runs a one-shot subcommand or boots the
+ * 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";
+async function main() {
+    const cli = await parseCli();
+    if (cli.done)
+        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.");
+        process.exit(1);
+    }
+    // Lazy-load Ink so subcommands don't pay the React boot cost.
+    const [{ render }, React, { App }] = await Promise.all([
+        import("ink"),
+        import("react"),
+        import("./app.js"),
+    ]);
+    // 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 });
+}
+main().catch((err) => {
+    console.error(err);
+    process.exit(1);
+});

package/dist/lib/diagnostics.d.ts

@@ -0,0 +1,66 @@
+export declare function collectDiagnostics(): {
+    version: string;
+    node: string;
+    nodeRequired: string;
+    nodeOk: boolean;
+    platform: string;
+    platformLabel: string;
+    termux: boolean;
+    termuxVersion: string;
+    stableUi: boolean;
+    tty: boolean;
+    configRoot: any;
+    configFile: any;
+    authFile: any;
+    authMode: string;
+    tmpdir: string;
+    memTotalMb: number;
+    memFreeMb: number;
+    providerId: any;
+    model: any;
+    keyPresent: boolean;
+    keyStatus: "ok" | "missing" | "unbound";
+    keyEnv: string;
+    skillsInstalled: number;
+    pluginsInstalled: number;
+    enabledSkills: any;
+    enabledPlugins: any;
+    sessionLogEnabled: boolean;
+    sessionCacheMb: number;
+    sessionFsync: "auto" | "off" | "on";
+    unclosedSessions: number;
+    sessionsDir: any;
+    sessionsCount: number;
+    sessionsBytes: number;
+    trustFile: any;
+    trusted: boolean;
+    shellDenyPatterns: number;
+    allowDangerous: boolean;
+    toolOutputLimit: number;
+    tokenBudget: number;
+    costBudgetUsd: number;
+    compactionEnabled: boolean;
+    compactionRatio: number;
+    compactionHeapMb: number;
+    compactionHeapUsedMb: number;
+    compactionForced: boolean;
+    serverCompactionAware: boolean;
+    shellActive: number;
+    shellPool: number;
+    shellSpawns: number;
+    shellMaxSpawn: number;
+    sseIdleMs: number;
+    toolProtocol: import("../agent/protocol-mode.js").ToolProtocol;
+    toolProtocolMode: string;
+    toolCapability: any;
+    loopExempt: string[];
+    modelMetaFile: string;
+    modelMeta: import("./model-meta.js").ModelMeta;
+    providers: {
+        id: string;
+        label: string;
+        env: string[];
+        keyPresent: boolean;
+    }[];
+};
+export declare function formatDiagnostics(info: any): string;

package/dist/lib/diagnostics.js

@@ -0,0 +1,195 @@
+/**
+ * Environment diagnostics for mobile / Termux troubleshooting.
+ *
+ * `fastcode doctor` prints the values below so a broken mobile install can be
+ * 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 { PROVIDERS } from "../providers/index.js";
+import { listInstalledSkills } from "../skills/manager.js";
+import { listInstalledPlugins } from "../plugins/manager.js";
+import { findUnclosedSessions, fsyncMode, loggingEnabled, listSessions, sessionCacheLimitBytes } from "../session/log.js";
+import { isTrusted } from "../config/trust.js";
+import { DEFAULT_DENY_PATTERNS, loopExemptTools } from "../agent/guards.js";
+import { toolOutputLimit } from "../agent/limits.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;
+}
+function nodeIsSupported() {
+    const [major = 0, minor = 0] = process.versions.node.split(".").map(Number);
+    const [reqMajor = 0, reqMinor = 0] = NODE_REQUIRED.split(".").map(Number);
+    return major > reqMajor || (major === reqMajor && minor >= reqMinor);
+}
+export function collectDiagnostics() {
+    const config = loadConfig();
+    let paths;
+    try {
+        paths = getPaths();
+    }
+    catch {
+        paths = undefined;
+    }
+    const provider = PROVIDERS.find((p) => p.id === config.providerId);
+    const keyLookup = provider && provider.authEnv.length > 0
+        ? resolveApiKey(provider.id, config.model, provider.authEnv)
+        : { status: "ok" };
+    const keyPresent = Boolean(provider) && (provider.authEnv.length === 0 || keyLookup.status === "ok");
+    let skillsInstalled = 0;
+    let pluginsInstalled = 0;
+    try {
+        skillsInstalled = listInstalledSkills().length;
+    }
+    catch {
+        // A broken skills dir must not break the whole report.
+    }
+    try {
+        pluginsInstalled = listInstalledPlugins().length;
+    }
+    catch {
+        // 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,
+        nodeRequired: NODE_REQUIRED,
+        nodeOk: nodeIsSupported(),
+        platform,
+        platformLabel: platformLabel(),
+        termux: platform === "termux",
+        termuxVersion: process.env["TERMUX_VERSION"] ?? null,
+        stableUi: shouldUseStableTerminalUi(),
+        tty: Boolean(process.stdout.isTTY),
+        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,
+        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),
+        trustFile: paths?.trust,
+        trusted: isTrusted(process.cwd()),
+        shellDenyPatterns: DEFAULT_DENY_PATTERNS.length,
+        allowDangerous: ["1", "true", "yes", "on"].includes((process.env["FASTCODE_ALLOW_DANGEROUS"] ?? "").trim().toLowerCase()),
+        toolOutputLimit: toolOutputLimit(),
+        tokenBudget: positiveEnv("FASTCODE_TOKEN_BUDGET"),
+        costBudgetUsd: positiveEnv("FASTCODE_COST_BUDGET_USD"),
+        compactionEnabled: compaction.enabled,
+        compactionRatio: compaction.localThresholdRatio,
+        compactionHeapMb: compaction.heapLimitMb,
+        compactionHeapUsedMb: process.memoryUsage().heapUsed / 1024 / 1024,
+        compactionForced: heapExceeded(compaction),
+        serverCompactionAware: compaction.serverCompactionAware,
+        shellActive: shells.active,
+        shellPool: shells.pool,
+        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,
+            env: p.authEnv,
+            keyPresent: p.authEnv.length === 0 || Boolean(resolveProviderKey(p.id, p.authEnv).key),
+        })),
+    };
+}
+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`);
+    lines.push("");
+    lines.push(`  node          ${info.node}  (needs >= ${info.nodeRequired})  [${info.nodeOk ? "ok" : "TOO OLD"}]`);
+    lines.push(`  platform      ${info.platformLabel}${info.termux ? " (Termux)" : ""}`);
+    lines.push(`  terminal      ${info.tty ? "interactive TTY" : "NOT a TTY — the TUI needs a real terminal"}`);
+    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)") + "   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 fsync " + info.sessionFsync + "   unclosed " + info.unclosedSessions + "   " + (info.sessionsDir ?? "(unavailable)"));
+    lines.push("  shell guard   " + info.shellDenyPatterns + " deny patterns" + (info.allowDangerous ? "   [FASTCODE_ALLOW_DANGEROUS is ON]" : ""));
+    lines.push("  tool output   " + info.toolOutputLimit + " chars max (streaming cap)");
+    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)}% · heap ${info.compactionHeapUsedMb.toFixed(1)}/${info.compactionHeapMb}MB${info.compactionForced ? " [FORCED]" : ""}${info.serverCompactionAware ? " · server-aware" : ""}`);
+    lines.push(`  shell pool    ${info.shellActive} active · ${info.shellPool} 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}`);
+    let apiKeyStatus;
+    if (info.keyPresent)
+        apiKeyStatus = "present";
+    else if (info.keyStatus === "unbound")
+        apiKeyStatus = `UNBOUND — a stored ${info.providerId} key isn't tied to a model; re-bind with /login ${info.providerId} ${info.model} <key>`;
+    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(`  plugins       ${info.pluginsInstalled} installed, ${info.enabledPlugins} enabled`);
+    lines.push("");
+    lines.push("  provider keys:");
+    for (const p of info.providers) {
+        lines.push(`    ${p.keyPresent ? "●" : "○"} ${p.id.padEnd(12)} ${p.env.join(" / ") || "(no key needed)"}`);
+    }
+    if (info.termux) {
+        lines.push("");
+        lines.push("  Termux tips:");
+        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/http.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Tiny fetch helpers. We standardize on globalThis.fetch (Node 18+).
+ *
+ * The `streamSSE` helper parses Server-Sent Events for any provider that uses
+ * the OpenAI-style `data: {...}\n\n` chunk format. Non-SSE providers (e.g.
+ * 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, options?: StreamSseOptions): AsyncGenerator<{
+    event: any;
+    data: string;
+}, void, unknown>;
+export declare function probeConnectivity(url: string, timeoutMs?: number): Promise<boolean>;

package/dist/lib/http.js

@@ -0,0 +1,128 @@
+/**
+ * Tiny fetch helpers. We standardize on globalThis.fetch (Node 18+).
+ *
+ * The `streamSSE` helper parses Server-Sent Events for any provider that uses
+ * the OpenAI-style `data: {...}\n\n` chunk format. Non-SSE providers (e.g.
+ * Anthropic's older streaming) handle their own parsing.
+ */
+export async function fetchJson(url, init = {}) {
+    const res = await fetch(url, {
+        ...init,
+        headers: { "content-type": "application/json", accept: "application/json", ...(init.headers ?? {}) },
+    });
+    if (!res.ok) {
+        const body = await res.text().catch(() => "");
+        throw new Error(`${res.status} ${res.statusText}: ${body.slice(0, 500)}`);
+    }
+    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, options = {}) {
+    if (!res.ok) {
+        const body = await res.text().catch(() => "");
+        throw new Error(`${res.status} ${res.statusText}: ${body.slice(0, 500)}`);
+    }
+    if (!res.body)
+        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 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 chunkText = buffer.slice(0, sep);
+            buffer = buffer.slice(sep + 2);
+            const ev = parseSseChunk(chunkText);
+            if (ev)
+                yield ev;
+            sep = buffer.indexOf("\n\n");
+        }
+    }
+    // Flush trailing event without final \n\n (some servers do this).
+    const trailing = buffer.trim();
+    if (trailing) {
+        const ev = parseSseChunk(trailing);
+        if (ev)
+            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 = [];
+    for (const lineRaw of chunk.split("\n")) {
+        const line = lineRaw.replace(/\r$/, "");
+        if (!line || line.startsWith(":"))
+            continue;
+        if (line.startsWith("event:"))
+            event = line.slice(6).trim();
+        else if (line.startsWith("data:"))
+            dataLines.push(line.slice(5).trimStart());
+    }
+    if (dataLines.length === 0)
+        return undefined;
+    return { event, data: dataLines.join("\n") };
+}

package/dist/lib/markdown.d.ts

@@ -0,0 +1 @@
+export declare function renderMarkdown(md: any): any;

package/dist/lib/markdown.js

@@ -0,0 +1,32 @@
+/**
+ * Markdown → ANSI rendering for terminal output.
+ *
+ * We use marked + marked-terminal because it gives us proper code-fence
+ * syntax highlighting (via cli-highlight) without us hand-rolling a
+ * markdown parser. The result is a fully-formatted ANSI string we can
+ * print directly inside an Ink <Text>.
+ */
+import { marked } from "marked";
+import { markedTerminal } from "marked-terminal";
+let configured = false;
+function configure() {
+    if (configured)
+        return;
+    marked.use(markedTerminal({
+        reflowText: false,
+        tab: 2,
+    }));
+    configured = true;
+}
+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+$/, "");
+    }
+    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;