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

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/providers/deepseek.js

@@ -9,7 +9,7 @@ export const deepseekProvider = {
     label: "DeepSeek",
     authEnv: ["DEEPSEEK_API_KEY"],
     baseUrl: BASE,
-    defaultModel: "deepseek-v4-pro",
+    defaultModel: "deepseek-flash",
     listModels: (apiKey) => listModelsHttp({ baseUrl: BASE, apiKey, staticModels: STATIC }),
     stream: (req, apiKey) => streamChatCompletion(req, { baseUrl: BASE, apiKey, staticModels: STATIC, reasoning: "openai" }),
     supportsReasoning: () => true,

package/dist/providers/openaiCompatible.d.ts

@@ -1,4 +1,26 @@
-export declare function streamChatCompletion(req: any, opts: any): AsyncGenerator<{
+import { type RequestSpec } from "./spec.js";
+export interface ModelInfo {
+    id: string;
+    label?: string;
+    [key: string]: any;
+}
+export interface StreamOptions {
+    baseUrl: string;
+    apiKey?: string;
+    chatPath?: string;
+    modelsPath?: string | null;
+    query?: Record<string, string>;
+    pathParams?: Record<string, string>;
+    authHeaderName?: string;
+    authPrefix?: string;
+    staticModels?: ModelInfo[];
+    extraHeaders?: Record<string, string>;
+    /** Legacy auth prefix, e.g. "Bearer". Prefer authPrefix for new callers. */
+    authHeader?: string;
+    reasoning?: "openai" | "openrouter" | "none" | string;
+}
+export declare function toRequestSpec(opts: StreamOptions): RequestSpec;
+export declare function streamChatCompletion(req: any, opts: StreamOptions): AsyncGenerator<{
     delta: string;
     done: boolean;
     reasoning?: undefined;
@@ -23,4 +45,4 @@ export declare function streamChatCompletion(req: any, opts: any): AsyncGenerato
     reasoning?: undefined;
     toolCalls?: undefined;
 }, void, unknown>;
-export declare function listModelsHttp(opts: any): Promise<any>;
+export declare function listModelsHttp(opts: StreamOptions): Promise<any>;

package/dist/providers/openaiCompatible.js

@@ -1,5 +1,17 @@
 import { fetchJson, streamSSE } from "../lib/http.js";
 import { finalizeToolCalls, mergeToolCallDelta } from "../lib/native-tools.js";
+import { buildHeaders, buildRequestUrl } from "./spec.js";
+export function toRequestSpec(opts) {
+    return {
+        baseUrl: trim(opts.baseUrl),
+        chatPath: opts.chatPath,
+        modelsPath: opts.modelsPath,
+        query: opts.query,
+        pathParams: opts.pathParams,
+        authHeaderName: opts.authHeaderName,
+        authPrefix: opts.authPrefix ?? (opts.authHeader !== undefined ? `${opts.authHeader} ` : undefined),
+    };
+}
 /** Build a chat-completions body in the classic or the newer (compat) dialect. */
 function buildBody(req, compat, opts, includeReasoning = true) {
     const messages = [];
@@ -48,6 +60,7 @@ function buildBody(req, compat, opts, includeReasoning = true) {
 }
 export async function* streamChatCompletion(req, opts) {
     const hasReasoning = Boolean(req.reasoningEffort && req.reasoningEffort !== "auto" && opts.reasoning && opts.reasoning !== "none");
+    const spec = toRequestSpec(opts);
     const send = async (compat, includeReasoning = hasReasoning) => {
         const headers = {
             "content-type": "application/json",
@@ -55,10 +68,10 @@ export async function* streamChatCompletion(req, opts) {
             ...(opts.extraHeaders ?? {}),
         };
         if (opts.apiKey)
-            headers["authorization"] = (opts.authHeader ?? "Bearer") + " " + opts.apiKey;
+            Object.assign(headers, buildHeaders(spec, opts.apiKey));
         if (req.clientRequestId)
             headers["idempotency-key"] = req.clientRequestId;
-        return await fetch(trim(opts.baseUrl) + "/chat/completions", {
+        return await fetch(buildRequestUrl(spec, opts.chatPath ?? "/chat/completions"), {
             method: "POST",
             headers,
             body: JSON.stringify(buildBody(req, compat, opts, includeReasoning)),
@@ -130,13 +143,14 @@ export async function* streamChatCompletion(req, opts) {
 }
 export async function listModelsHttp(opts) {
     const staticModels = opts.staticModels ?? [];
+    if (opts.modelsPath === null)
+        return staticModels;
     if (!opts.apiKey && staticModels.length)
         return staticModels;
     try {
-        const headers = {};
-        if (opts.apiKey)
-            headers["authorization"] = (opts.authHeader ?? "Bearer") + " " + opts.apiKey;
-        const json = await fetchJson(trim(opts.baseUrl) + "/models", { headers });
+        const spec = toRequestSpec(opts);
+        const headers = opts.apiKey ? buildHeaders(spec, opts.apiKey) : {};
+        const json = await fetchJson(buildRequestUrl(spec, opts.modelsPath ?? "/models"), { headers });
         const ids = (json.data ?? [])
             .map((m) => m.id)
             .filter((id) => typeof id === "string" && id.length > 0);

package/dist/providers/spec.d.ts

@@ -0,0 +1,12 @@
+export interface RequestSpec {
+    baseUrl: string;
+    chatPath?: string;
+    modelsPath?: string | null;
+    query?: Record<string, string>;
+    pathParams?: Record<string, string>;
+    authHeaderName?: string;
+    authPrefix?: string;
+}
+export declare function resolveBaseUrl(spec: RequestSpec): string;
+export declare function buildRequestUrl(spec: RequestSpec, path: string, params?: Record<string, string>): string;
+export declare function buildHeaders(spec: RequestSpec, apiKey: string, extra?: Record<string, string>): Record<string, string>;

package/dist/providers/spec.js

@@ -0,0 +1,29 @@
+const ENV_MAP = {
+    region: "AWS_REGION",
+    account_id: "CLOUDFLARE_ACCOUNT_ID",
+    project_id: "GOOGLE_CLOUD_PROJECT",
+    deployment: "AZURE_OPENAI_DEPLOYMENT",
+};
+export function resolveBaseUrl(spec) {
+    return spec.baseUrl.replace(/\{(\w+)\}/g, (_, key) => {
+        const envName = ENV_MAP[key];
+        const value = envName ? process.env[envName] : undefined;
+        if (!value)
+            throw new Error(`Missing ${envName ?? key} for placeholder {${key}}`);
+        return value;
+    });
+}
+export function buildRequestUrl(spec, path, params) {
+    const base = resolveBaseUrl(spec);
+    const merged = { ...spec.pathParams, ...params };
+    const resolvedPath = path.replace(/\{(\w+)\}/g, (_, key) => merged[key] ?? `{${key}}`);
+    const query = spec.query ? "?" + new URLSearchParams(spec.query).toString() : "";
+    return base + resolvedPath + query;
+}
+export function buildHeaders(spec, apiKey, extra) {
+    const headers = {
+        [spec.authHeaderName ?? "authorization"]: (spec.authPrefix ?? "Bearer ") + apiKey,
+        ...extra,
+    };
+    return headers;
+}

package/dist/session/log.d.ts

@@ -14,24 +14,36 @@ export interface SessionSummary {
     messages: number;
     lastTs: number;
 }
+/** Reserved slot for conversation compaction at the exit save point. */
+export interface SessionCompactionSlot {
+    source?: "local" | "server" | "none";
+    summaryRef?: string | null;
+    pending?: boolean;
+}
+export interface SessionCloseInfo {
+    reason?: "exit" | "signal" | "fatal" | "close";
+    compaction?: SessionCompactionSlot;
+}
 export declare function sessionCacheLimitBytes(): number;
 export declare function loggingEnabled(): boolean;
 export declare function projectionPath(file: string): string;
 export declare function fsyncMode(): "on" | "off" | "auto";
 export declare function fsyncEnabled(type?: string): boolean;
+/** Summary files referenced by older compacted facts in this session. */
+export declare function staleSummaryRefs(file: string): string[];
 export declare function createSessionLog(meta?: Record<string, any>): {
     id: string;
     file: string;
     append: (entry: Record<string, any>) => number;
     count(): number;
-    close(): void;
+    close(info?: SessionCloseInfo): void;
 };
 export declare function openSessionLog(file: string, meta?: Record<string, any>): {
     id: string;
     file: string;
     append: (entry: Record<string, any>) => number;
     count(): number;
-    close(): void;
+    close(info?: SessionCloseInfo): void;
 };
 export declare function listSessions(): {
     id: string;

package/dist/session/log.js

@@ -10,9 +10,10 @@
  *   FASTCODE_SESSION_CACHE_MB=N   sessions cache cap in MB (default 256)
  *   FASTCODE_FSYNC=0|1            force checkpoint fsync off/on
  */
-import { appendFileSync, closeSync, existsSync, fsyncSync, mkdirSync, openSync, readdirSync, readFileSync, readSync, rmSync, statSync, writeFileSync, writeSync } from "node:fs";
-import { basename, join } from "node:path";
+import { appendFileSync, closeSync, existsSync, fsyncSync, mkdirSync, openSync, readdirSync, readFileSync, readSync, rmSync, statSync, writeSync } from "node:fs";
+import { join } from "node:path";
 import { getPaths } from "../config/paths.js";
+import { buildProjection, writeProjection } from "./projection.js";
 const NL = String.fromCharCode(10);
 export function sessionCacheLimitBytes() {
     const mb = Number(process.env["FASTCODE_SESSION_CACHE_MB"]);
@@ -63,6 +64,23 @@ function writeLine(file, line, type) {
         closeSync(fd);
     }
 }
+function fsyncPath(file) {
+    if (!existsSync(file))
+        return;
+    try {
+        const fd = openSync(file, "r");
+        try {
+            fsyncSync(fd);
+        }
+        finally {
+            closeSync(fd);
+        }
+    }
+    catch {
+        // FUSE / read-only filesystems may reject fsync; the append is still
+        // best effort and the caller already caught close-level failures.
+    }
+}
 function countLines(file) {
     if (!existsSync(file))
         return 0;
@@ -101,10 +119,25 @@ function openLog(id, file, meta) {
         count() {
             return seq;
         },
-        close() {
-            append({ type: "session_end" });
+        close(info = {}) {
+            append({
+                type: "session_end",
+                reason: info.reason ?? "close",
+                // Reserved extension point: future compaction can fill this
+                // slot without changing the session_end event shape.
+                compaction: {
+                    source: info.compaction?.source ?? "none",
+                    summaryRef: info.compaction?.summaryRef ?? null,
+                    pending: info.compaction?.pending ?? false,
+                },
+            });
             closed = true;
             try {
+                // Snapshot + manifest are written while the facts still exist;
+                // pruning later keeps this verified copy.
+                ensureProjection(file);
+                fsyncPath(file);
+                fsyncPath(projectionPath(file));
                 pruneSessions();
             }
             catch {
@@ -113,6 +146,21 @@ function openLog(id, file, meta) {
         },
     };
 }
+/** Summary files referenced by older compacted facts in this session. */
+export function staleSummaryRefs(file) {
+    let facts;
+    try {
+        facts = readSession(file);
+    }
+    catch {
+        return [];
+    }
+    const compacted = facts.filter((fact) => fact?.type === "compacted");
+    const latest = compacted.at(-1)?.summaryRef;
+    return Array.from(new Set(compacted
+        .map((fact) => fact.summaryRef)
+        .filter((ref) => typeof ref === "string" && ref.length > 0 && ref !== latest)));
+}
 export function createSessionLog(meta = {}) {
     const { sessions } = getPaths();
     mkdirSync(sessions, { recursive: true });
@@ -287,32 +335,13 @@ export function latestUnclosedSession() {
     return findUnclosedSessions()[0];
 }
 function ensureProjection(file) {
-    const target = projectionPath(file);
-    if (existsSync(target))
-        return;
+    // Always refresh from the facts that still exist: a projection written at
+    // an earlier checkpoint may be stale by the time we close or prune. If the
+    // JSONL is already gone, leave the verified projection untouched.
     const entries = readSession(file);
     if (entries.length === 0)
         return;
-    const summary = summarize(basename(file).replace(/[.]jsonl$/, ""), file, entries);
-    const lastUser = [...entries].reverse().find((entry) => entry.type === "message" && entry.role === "user");
-    const lastAssistant = [...entries].reverse().find((entry) => entry.type === "message" && entry.role === "assistant");
-    const payload = {
-        version: 1,
-        kind: "pruned_session",
-        source: basename(file),
-        createdAt: new Date().toISOString(),
-        summary: {
-            cwd: summary.cwd,
-            providerId: summary.providerId,
-            model: summary.model,
-            turns: summary.turns,
-            messages: summary.messages,
-            activeFiles: summary.activeFiles.slice(0, 200),
-            lastUser: typeof lastUser?.content === "string" ? lastUser.content.slice(0, 2000) : "",
-            lastAssistant: typeof lastAssistant?.content === "string" ? lastAssistant.content.slice(0, 2000) : "",
-        },
-    };
-    writeFileSync(target, JSON.stringify(payload, null, 2), "utf8");
+    writeProjection(file, buildProjection(entries), entries);
 }
 export function pruneSessions(limit = sessionCacheLimitBytes()) {
     const all = listSessions();

package/dist/session/projection.d.ts

@@ -11,6 +11,17 @@ export interface ProjectionFingerprint {
     cwdDigest: string;
     compactionSource: "local" | "server" | "none";
 }
+export interface ProjectionManifest {
+    version: 1;
+    algorithm: "sha256";
+    savedAt: string;
+    /** Hash of the projection content (messages/meta/files). */
+    contentHash: string;
+    /** Hash of the source JSONL facts at save time, when available. */
+    sessionHash?: string;
+    /** Highest fact sequence covered by this projection. */
+    lastFactSeq?: number;
+}
 export interface Projection {
     version: 1;
     kind: "projection";
@@ -21,6 +32,15 @@ export interface Projection {
     messages: ChatMessage[];
     activeFiles: ActiveFile[];
     lastFactSeq: number;
+    /** Integrity data written at save/prune time; never re-derived from facts. */
+    manifest?: ProjectionManifest;
+}
+export type ProjectionReadStatus = "ok" | "legacy" | "hash_mismatch" | "corrupt" | "missing";
+export interface ProjectionReadResult {
+    status: ProjectionReadStatus;
+    projection?: Projection;
+    expectedHash?: string;
+    actualHash?: string;
 }
 export interface ResumeState {
     projection: Projection;
@@ -37,7 +57,20 @@ export declare function sessionMetaFromFacts(facts: any[]): SessionMeta;
 export declare function sessionMetaFromFile(file: string): SessionMeta;
 export declare function factsToMessages(facts: any[]): ChatMessage[];
 export declare function compactionSourceFromFacts(facts: any[]): ProjectionFingerprint["compactionSource"];
+export declare function projectionContentHash(projection: Projection): string;
+export declare function factsContentHash(facts: any[]): string;
+/**
+ * Keep native tool_call/tool_result pairs complete. Orphan tool messages left
+ * behind by projection truncation are dropped; missing results are synthesized
+ * with the existing "execution unknown" notice so a resumed model never waits
+ * for a result that cannot arrive.
+ */
+export declare function pairToolMessages(messages: ChatMessage[]): {
+    messages: ChatMessage[];
+    repaired: boolean;
+};
 export declare function buildProjection(facts: any[], metaOverride?: Partial<SessionMeta>): Projection;
+export declare function readProjectionResult(file: string): ProjectionReadResult;
 export declare function readProjection(file: string): Projection | undefined;
-export declare function writeProjection(file: string, projection: Projection): void;
+export declare function writeProjection(file: string, projection: Projection, facts?: any[]): void;
 export declare function resumeSession(file: string, currentCwd?: string): ResumeState;