termux-dev 1.6.0 → 1.8.1

package/dist/core/cost.js

@@ -0,0 +1,191 @@
+/**
+ * What a request cost, and how sure we are about it.
+ *
+ * Sources, best first:
+ *   reported    the provider put the cost into its response (OpenRouter `usage.cost`, LiteLLM, ...)
+ *   configured  the user wrote the prices into the config ("prices")
+ *   listed      the endpoint's own model list carries the prices (OpenRouter, LiteLLM)
+ *   estimated   the models.dev catalogue price of the same model; a gateway may charge differently
+ *   free        a local server or a ":free" model
+ * When none of them knows the model the cost is left undefined: "unknown" is shown as such and
+ * never as $0.
+ */
+const PER_MILLION = 1_000_000;
+const finite = (value) => typeof value === 'number' && Number.isFinite(value) && value >= 0;
+/** The cost of the tokens at the given rates. */
+export function computeCost(rates, usage) {
+    const prompt = Math.max(0, usage.promptTokens || 0);
+    const tier = rates.tier && prompt > rates.tier.over ? rates.tier : null;
+    const input = tier?.input ?? rates.input;
+    const output = tier?.output ?? rates.output;
+    const cacheRead = tier ? (tier.cacheRead ?? rates.cacheRead) : rates.cacheRead;
+    const cacheWrite = tier ? (tier.cacheWrite ?? rates.cacheWrite) : rates.cacheWrite;
+    const read = Math.min(prompt, Math.max(0, usage.cacheReadTokens || 0));
+    const written = Math.min(prompt - read, Math.max(0, usage.cacheWriteTokens || 0));
+    const plain = prompt - read - written;
+    // Without a cache price the cached tokens cost as much as ordinary input.
+    let cost = plain * input + read * (cacheRead ?? input) + written * (cacheWrite ?? input);
+    const completion = Math.max(0, usage.completionTokens || 0);
+    const reasoning = Math.min(completion, Math.max(0, usage.reasoningTokens || 0));
+    if (rates.reasoning !== undefined && reasoning > 0) {
+        cost += (completion - reasoning) * output + reasoning * rates.reasoning;
+    }
+    else {
+        cost += completion * output;
+    }
+    return cost / PER_MILLION;
+}
+/** A price as the OpenRouter list writes it: USD per token, often a string. */
+function perToken(value) {
+    const n = typeof value === 'string' ? Number(value) : value;
+    return finite(n) ? n * PER_MILLION : undefined;
+}
+/**
+ * Reads the prices from one entry of an endpoint's model list. Understands the OpenRouter
+ * schema (`pricing.prompt` / `completion` / `input_cache_read` in USD per token) and the
+ * LiteLLM schema (`input_cost_per_token`). Returns undefined when the entry has no prices.
+ * A negative price (OpenRouter's "variable") is not a price.
+ */
+export function priceFromModelEntry(entry) {
+    if (!entry || typeof entry !== 'object')
+        return undefined;
+    const pricing = entry.pricing;
+    if (pricing && typeof pricing === 'object') {
+        const input = perToken(pricing.prompt ?? pricing.input);
+        const output = perToken(pricing.completion ?? pricing.output);
+        if (input !== undefined && output !== undefined) {
+            const rates = { input, output };
+            const read = perToken(pricing.input_cache_read ?? pricing.cache_read);
+            const write = perToken(pricing.input_cache_write ?? pricing.cache_write);
+            const reasoning = perToken(pricing.internal_reasoning);
+            if (read !== undefined)
+                rates.cacheRead = read;
+            if (write !== undefined)
+                rates.cacheWrite = write;
+            if (reasoning !== undefined && reasoning > 0 && reasoning !== output)
+                rates.reasoning = reasoning;
+            return rates;
+        }
+    }
+    const info = entry.model_info ?? entry;
+    const input = perToken(info.input_cost_per_token);
+    const output = perToken(info.output_cost_per_token);
+    if (input !== undefined && output !== undefined) {
+        const rates = { input, output };
+        const read = perToken(info.cache_read_input_token_cost);
+        const write = perToken(info.cache_creation_input_token_cost);
+        if (read !== undefined)
+            rates.cacheRead = read;
+        if (write !== undefined)
+            rates.cacheWrite = write;
+        return rates;
+    }
+    return undefined;
+}
+function numberOf(value) {
+    const n = typeof value === 'string' ? Number(value) : value;
+    return finite(n) ? n : undefined;
+}
+/**
+ * The cost the provider itself reported in the usage block (several spellings exist).
+ * Returns undefined when it did not report one.
+ */
+export function reportedCost(usage) {
+    if (!usage || typeof usage !== 'object')
+        return undefined;
+    for (const key of ['cost', 'total_cost', 'cost_usd', 'estimated_cost']) {
+        const value = usage[key];
+        const direct = numberOf(value);
+        if (direct !== undefined)
+            return direct;
+        if (value && typeof value === 'object') {
+            const nested = numberOf(value.total ?? value.total_cost ?? value.usd);
+            if (nested !== undefined)
+                return nested;
+        }
+    }
+    return undefined;
+}
+export function isLocalBaseUrl(baseUrl) {
+    if (!baseUrl)
+        return false;
+    let host = '';
+    try {
+        host = new URL(baseUrl).hostname.toLowerCase();
+    }
+    catch {
+        return false;
+    }
+    return (host === 'localhost' || host === '[::1]' || host === '::1' ||
+        /^127\./.test(host) || /^10\./.test(host) || /^192\.168\./.test(host) || /^172\.(1[6-9]|2\d|3[01])\./.test(host) ||
+        host.endsWith('.local'));
+}
+export function isFreeModel(model, baseUrl) {
+    const id = (model || '').toLowerCase().trim();
+    return id.endsWith(':free') || isLocalBaseUrl(baseUrl);
+}
+/**
+ * "$0.0123" exact, "~$0.0123" estimated, "$0.0123+" when some requests are missing,
+ * "n/a" when nothing could be priced at all.
+ */
+export function formatMoney(cost, state = {}) {
+    const unpriced = state.unpriced ?? 0;
+    const priced = state.priced ?? (cost > 0 ? 1 : 0);
+    if (unpriced > 0 && priced === 0 && cost === 0)
+        return 'n/a';
+    const digits = cost >= 1 ? 2 : 4;
+    let text = `$${cost.toFixed(digits)}`;
+    if (state.estimated)
+        text = `~${text}`;
+    if (unpriced > 0)
+        text += '+';
+    return text;
+}
+/** One line that says what the number means (for /usage). */
+export function describeCostState(state) {
+    const parts = [];
+    if (state.estimated)
+        parts.push('estimated from catalogue prices');
+    if ((state.unpriced ?? 0) > 0)
+        parts.push(`${state.unpriced} request${state.unpriced === 1 ? '' : 's'} without a known price`);
+    return parts.join(', ');
+}
+/** Adds up the cost of the requests of a session. */
+export class CostLedger {
+    total = 0;
+    estimated = false;
+    unpriced = 0;
+    priced = 0;
+    add(usage) {
+        if (!usage)
+            return;
+        if (typeof usage.cost === 'number' && Number.isFinite(usage.cost)) {
+            this.total += usage.cost;
+            this.priced++;
+            if (usage.costSource === 'estimated')
+                this.estimated = true;
+        }
+        else {
+            this.unpriced++;
+        }
+    }
+    reset() {
+        this.total = 0;
+        this.estimated = false;
+        this.unpriced = 0;
+        this.priced = 0;
+    }
+    /** Restores a saved session (only the total was stored; it is shown as an estimate if it was one). */
+    restore(total, estimated = false) {
+        this.reset();
+        this.total = Number.isFinite(total) ? total : 0;
+        this.estimated = estimated;
+        this.priced = this.total > 0 ? 1 : 0;
+    }
+    state() {
+        return { estimated: this.estimated, unpriced: this.unpriced, priced: this.priced };
+    }
+    format() {
+        return formatMoney(this.total, this.state());
+    }
+}

package/dist/core/formats.js

@@ -0,0 +1,199 @@
+import path from 'path';
+import { devxDir, readJsonFile } from './catalog-util.js';
+import { ensureSecureDir, writeSecureFile } from './secure-file.js';
+import { isLocalBaseUrl } from './cost.js';
+import { detectRoute, setRouteResolver } from './reasoning.js';
+export const API_FORMATS = ['openai', 'anthropic'];
+export function isApiFormat(value) {
+    return value === 'openai' || value === 'anthropic';
+}
+/** The format a base URL names by itself, if it does. */
+export function formatFromBaseUrl(baseUrl) {
+    if (!baseUrl)
+        return null;
+    try {
+        const u = new URL(baseUrl);
+        if (u.hostname.toLowerCase() === 'api.anthropic.com')
+            return 'anthropic';
+        if (u.pathname.toLowerCase().split('/').includes('anthropic'))
+            return 'anthropic';
+    }
+    catch { }
+    return null;
+}
+/**
+ * The part of a base URL that both formats share: "https://host/v1" and "https://host" give
+ * "https://host". Returns null for URLs with another path (a gateway with its own layout),
+ * which are not probed for a second format.
+ */
+export function gatewayRoot(baseUrl) {
+    try {
+        const u = new URL(baseUrl);
+        const rest = u.pathname.replace(/\/+$/, '');
+        if (rest !== '' && rest !== '/v1')
+            return null;
+        return u.origin;
+    }
+    catch {
+        return null;
+    }
+}
+const POSITIVE_TTL_MS = 24 * 60 * 60 * 1000;
+const NEGATIVE_TTL_MS = 6 * 60 * 60 * 1000;
+export class FormatStore {
+    entries = new Map();
+    static key(root) {
+        return root.replace(/\/+$/, '').toLowerCase();
+    }
+    get(root) {
+        return this.entries.get(FormatStore.key(root));
+    }
+    set(root, record) {
+        this.entries.set(FormatStore.key(root), record);
+    }
+    clear() {
+        this.entries.clear();
+    }
+    isFresh(root, now = Date.now()) {
+        const record = this.get(root);
+        if (!record)
+            return false;
+        return now - record.at < (record.anthropic.length > 0 ? POSITIVE_TTL_MS : NEGATIVE_TTL_MS);
+    }
+    toJSON() {
+        return { version: 1, gateways: Object.fromEntries(this.entries) };
+    }
+    load(raw) {
+        if (!raw || raw.version !== 1 || typeof raw.gateways !== 'object')
+            return;
+        for (const [key, r] of Object.entries(raw.gateways)) {
+            if (r && typeof r.at === 'number' && Array.isArray(r.openai) && Array.isArray(r.anthropic)) {
+                this.entries.set(key, { at: r.at, openai: r.openai.map(String), anthropic: r.anthropic.map(String) });
+            }
+        }
+    }
+}
+export const formatStore = new FormatStore();
+const lower = (s) => s.toLowerCase().trim();
+/**
+ * Which format a request for this model uses. Decided without network access, from the base
+ * URL and what discovery remembered.
+ */
+export function resolveFormat(config) {
+    if (isApiFormat(config.apiFormat))
+        return config.apiFormat;
+    const named = formatFromBaseUrl(config.baseUrl);
+    if (named)
+        return named;
+    const root = config.baseUrl ? gatewayRoot(config.baseUrl) : null;
+    const record = root ? formatStore.get(root) : undefined;
+    const model = lower(config.model || '');
+    if (!record || !model)
+        return 'openai';
+    const inOpenAI = record.openai.some((id) => lower(id) === model);
+    const inAnthropic = record.anthropic.some((id) => lower(id) === model);
+    if (inAnthropic && !inOpenAI)
+        return 'anthropic';
+    if (inAnthropic && inOpenAI)
+        return /claude/.test(model) ? 'anthropic' : 'openai';
+    if (inOpenAI)
+        return 'openai';
+    // A model typed by hand: Claude models of a gateway that lists them only in the Anthropic format.
+    if (/^claude/.test(model) && record.anthropic.length > 0 && !record.openai.some((id) => /claude/i.test(id)))
+        return 'anthropic';
+    return 'openai';
+}
+/** The reasoning parameters are written for the route; the Anthropic format always uses its own. */
+export function routeFor(config) {
+    return resolveFormat(config) === 'anthropic' ? 'anthropic' : undefined;
+}
+function idsOf(body) {
+    const items = Array.isArray(body) ? body : Array.isArray(body?.data) ? body.data : Array.isArray(body?.models) ? body.models : [];
+    return items.map((m) => (typeof m === 'string' ? m : m?.id ?? m?.name)).filter((id) => typeof id === 'string' && id.length > 0);
+}
+/**
+ * Asks the gateway for its model list in both formats (two small GET requests to the user's own
+ * base URL, with the user's own key). Returns null when the URL is not a plain gateway.
+ */
+export async function discoverFormats(input) {
+    const root = gatewayRoot(input.baseUrl);
+    if (!root)
+        return null;
+    const doFetch = input.fetchImpl ?? fetch;
+    const timeout = input.timeoutMs ?? 4000;
+    const url = `${root}/v1/models`;
+    const list = async (headers) => {
+        try {
+            const res = await doFetch(url, { headers, signal: AbortSignal.timeout(timeout) });
+            return res.ok ? idsOf(await res.json()) : null;
+        }
+        catch {
+            return null;
+        }
+    };
+    const key = input.apiKey && input.apiKey !== 'ollama' ? input.apiKey : '';
+    const [asOpenAI, asAnthropic] = await Promise.all([
+        list(key ? { Authorization: `Bearer ${key}` } : {}),
+        list({ 'anthropic-version': '2023-06-01', ...(key ? { 'x-api-key': key } : {}) }),
+    ]);
+    if (asOpenAI === null && asAnthropic === null)
+        return null;
+    const openai = asOpenAI ?? [];
+    const known = new Set(openai.map(lower));
+    // A gateway that ignores the Anthropic headers answers with the same list: no second format.
+    const only = (asAnthropic ?? []).filter((id) => !known.has(lower(id)));
+    const anthropic = asOpenAI === null ? (asAnthropic ?? []) : only;
+    return { at: Date.now(), openai, anthropic };
+}
+/** Models that are reachable only through the Anthropic format (for the model picker). */
+export function anthropicOnlyModels(baseUrl) {
+    const root = baseUrl ? gatewayRoot(baseUrl) : null;
+    return (root ? formatStore.get(root)?.anthropic : undefined) ?? [];
+}
+// ───────────────────────── remembering the answers ─────────────────────────
+export function loadFormatCache(dir = devxDir()) {
+    formatStore.load(readJsonFile(path.join(dir, 'formats.json')));
+}
+async function saveFormatCache(dir) {
+    try {
+        await ensureSecureDir(dir);
+        await writeSecureFile(path.join(dir, 'formats.json'), JSON.stringify(formatStore.toJSON()));
+    }
+    catch { }
+}
+const inflight = new Map();
+/**
+ * Makes sure a custom gateway has been asked about its formats (cached for a day). Vendors with
+ * a single format, local servers and `"probeEndpoints": false` are never asked.
+ */
+export async function refreshFormats(config, options = {}) {
+    const baseUrl = config.baseUrl || '';
+    if (!baseUrl || config.probeEndpoints === false || isApiFormat(config.apiFormat))
+        return null;
+    if (formatFromBaseUrl(baseUrl) || isLocalBaseUrl(baseUrl) || detectRoute(baseUrl) !== 'generic')
+        return null;
+    const root = gatewayRoot(baseUrl);
+    if (!root)
+        return null;
+    if (!options.force && formatStore.isFresh(root))
+        return formatStore.get(root) ?? null;
+    const pending = inflight.get(root);
+    if (pending)
+        return pending;
+    const job = (async () => {
+        const record = await discoverFormats({ baseUrl, apiKey: config.apiKey, fetchImpl: options.fetchImpl, timeoutMs: options.timeoutMs });
+        if (!record)
+            return null;
+        formatStore.set(root, record);
+        if (options.persist !== false)
+            await saveFormatCache(options.dir ?? devxDir());
+        return record;
+    })().finally(() => inflight.delete(root));
+    inflight.set(root, job);
+    return job;
+}
+/** Loads what was learned earlier and lets the reasoning settings follow the format. */
+export function installFormats(dir = devxDir()) {
+    loadFormatCache(dir);
+    setRouteResolver((config) => routeFor(config));
+}

package/dist/core/history.js

@@ -1,9 +1,27 @@
+const IMAGE_TOKEN_ESTIMATE = 1500;
+// Last-resort size for tool output that is still too large once everything
+// that can be dropped has been dropped.
+const EMERGENCY_TOOL_CHARS = 4000;
+function shortenMiddle(text, maxChars) {
+    if (text.length <= maxChars)
+        return text;
+    const head = Math.floor(maxChars * 0.4);
+    const tail = maxChars - head;
+    return `${text.slice(0, head)}\n[... ${text.length - maxChars} characters removed to fit the context window ...]\n${text.slice(text.length - tail)}`;
+}
 export class History {
     messages = [];
+    /** How often old messages had to be shortened or dropped, and how many were dropped (for /usage). */
+    compactions = 0;
+    droppedMessages = 0;
     constructor() { }
     addMessage(msg) {
         this.messages.push(msg);
     }
+    /** Forgets the message at `index` and everything after it (the system prompt at 0 stays). */
+    rewindBefore(index) {
+        this.messages = this.messages.slice(0, Math.max(1, index));
+    }
     updateSystemPrompt(content) {
         const idx = this.messages.findIndex(m => m.role === 'system');
         if (idx >= 0) {
@@ -28,6 +46,8 @@ export class History {
     }
     clear() {
         this.messages = [];
+        this.compactions = 0;
+        this.droppedMessages = 0;
     }
     getTotalTokens() {
         return this.estimateTokens(this.messages);
@@ -51,13 +71,21 @@ export class History {
                     t += 1.2;
                 }
                 else {
-                    t += 0.25;
+                    // Source code and JSON average ~3 characters per token; 0.25 (4 chars/token)
+                    // under-counts them and lets requests overflow the context window.
+                    t += 0.33;
                 }
             }
             return t;
         };
         for (const m of messages) {
             tokens += countStringTokens(m.content || '');
+            if (m.images && m.images.length > 0) {
+                tokens += m.images.length * IMAGE_TOKEN_ESTIMATE;
+            }
+            for (const t of m.thinking_blocks ?? []) {
+                tokens += countStringTokens(t.type === 'thinking' ? t.thinking : t.data);
+            }
             if (m.tool_calls) {
                 for (const tc of m.tool_calls) {
                     tokens += countStringTokens(tc.name);
@@ -129,6 +157,7 @@ export class History {
         }
         if (this.estimateTokens(blocks.flat()) <= maxTokens) {
             this.messages = blocks.flat();
+            this.compactions++;
             return true;
         }
         // Фаза 2: Удаление незащищенных блоков целиком (от старых к новым)
@@ -143,7 +172,28 @@ export class History {
                 blocks[i] = []; // помечаем как удаленный
             }
         }
+        // Фаза 3: остались только защищённые блоки, но они всё ещё не помещаются
+        // (например, огромный результат инструмента в последнем ходе). Сокращаем
+        // содержимое tool-сообщений, начиная со старых.
+        if (currentTokens > maxTokens) {
+            for (const block of blocks) {
+                if (currentTokens <= maxTokens)
+                    break;
+                for (const msg of block) {
+                    if (currentTokens <= maxTokens)
+                        break;
+                    if (msg.role === 'tool' && msg.content && msg.content.length > EMERGENCY_TOOL_CHARS) {
+                        const before = this.estimateTokens([msg]);
+                        msg.content = shortenMiddle(msg.content, EMERGENCY_TOOL_CHARS);
+                        currentTokens -= before - this.estimateTokens([msg]);
+                    }
+                }
+            }
+        }
+        const before = this.messages.length;
         this.messages = blocks.filter(b => b.length > 0).flat();
+        this.compactions++;
+        this.droppedMessages += before - this.messages.length;
         return true;
     }
 }

package/dist/core/hooks.js

@@ -0,0 +1,79 @@
+import { spawn } from 'child_process';
+const DEFAULT_TIMEOUT_S = 10;
+const MAX_OUTPUT = 4000;
+/** The entries of an event that apply to a tool. A matcher that is not a valid expression matches nothing. */
+export function matchingHooks(entries, toolName) {
+    if (!Array.isArray(entries))
+        return [];
+    return entries.filter((e) => {
+        if (!e || typeof e.command !== 'string' || !e.command.trim())
+            return false;
+        if (!e.matcher || e.matcher === '*')
+            return true;
+        try {
+            return new RegExp(`^(?:${e.matcher})$`).test(toolName);
+        }
+        catch {
+            return false;
+        }
+    });
+}
+export const runHookProcess = (entry, payload, env) => new Promise((resolve) => {
+    const isWindows = process.platform === 'win32';
+    const child = spawn(isWindows ? 'cmd' : 'sh', isWindows ? ['/c', entry.command] : ['-c', entry.command], {
+        env: { ...process.env, ...env },
+        stdio: ['pipe', 'pipe', 'pipe'],
+    });
+    let stdout = '';
+    let stderr = '';
+    let timedOut = false;
+    let settled = false;
+    const finish = (code) => {
+        if (settled)
+            return;
+        settled = true;
+        clearTimeout(timer);
+        resolve({ code, stdout: stdout.slice(0, MAX_OUTPUT), stderr: stderr.slice(0, MAX_OUTPUT), timedOut });
+    };
+    const timer = setTimeout(() => {
+        timedOut = true;
+        try {
+            child.kill('SIGKILL');
+        }
+        catch { }
+        finish(null);
+    }, (entry.timeout && entry.timeout > 0 ? entry.timeout : DEFAULT_TIMEOUT_S) * 1000);
+    child.stdout.on('data', (d) => { if (stdout.length < MAX_OUTPUT)
+        stdout += d; });
+    child.stderr.on('data', (d) => { if (stderr.length < MAX_OUTPUT)
+        stderr += d; });
+    child.on('error', () => finish(null));
+    child.on('close', (code) => finish(code));
+    child.stdin.on('error', () => { });
+    child.stdin.end(JSON.stringify(payload));
+});
+export async function runHooks(hooks, event, toolName, toolInput, toolResult, run = runHookProcess) {
+    const outcome = { notes: [] };
+    for (const entry of matchingHooks(hooks?.[event], toolName)) {
+        const payload = { event, tool_name: toolName, tool_input: toolInput };
+        if (toolResult !== undefined)
+            payload.tool_result = toolResult;
+        const result = await run(entry, payload, { DEVX_HOOK_EVENT: event, DEVX_TOOL_NAME: toolName });
+        const said = (result.stderr || result.stdout).trim();
+        if (result.timedOut) {
+            outcome.notes.push(`hook "${entry.command}" timed out`);
+        }
+        else if (result.code === 2) {
+            if (event === 'PreToolUse') {
+                outcome.blocked = said || `blocked by the hook "${entry.command}"`;
+                return outcome;
+            }
+            if (said)
+                outcome.notes.push(said);
+        }
+        else if (result.code !== 0) {
+            outcome.notes.push(`hook "${entry.command}" failed (exit ${result.code ?? 'none'})${said ? ': ' + said : ''}`);
+        }
+    }
+    return outcome;
+}

package/dist/core/i18n.js

@@ -0,0 +1,42 @@
+import { en } from './locales/en.js';
+import { ru } from './locales/ru.js';
+import { uk } from './locales/uk.js';
+import { de } from './locales/de.js';
+import { es } from './locales/es.js';
+import { fr } from './locales/fr.js';
+import { pt } from './locales/pt.js';
+import { zh } from './locales/zh.js';
+import { ja } from './locales/ja.js';
+export const LANGUAGES = [
+    { id: 'en', name: 'English' },
+    { id: 'ru', name: 'Русский' },
+    { id: 'uk', name: 'Українська' },
+    { id: 'de', name: 'Deutsch' },
+    { id: 'es', name: 'Español' },
+    { id: 'fr', name: 'Français' },
+    { id: 'pt', name: 'Português' },
+    { id: 'zh', name: 'Chinese' },
+    { id: 'ja', name: 'Japanese' },
+];
+export const LANGUAGE_IDS = LANGUAGES.map((l) => l.id);
+export const DEFAULT_LANGUAGE = 'en';
+const CATALOGS = { en, ru, uk, de, es, fr, pt, zh, ja };
+let current = DEFAULT_LANGUAGE;
+/** Switches the language. An unknown id (a typo in the config file) means English. */
+export function setLanguage(id) {
+    current = id && CATALOGS[id] ? id : DEFAULT_LANGUAGE;
+    return current;
+}
+export function getLanguage() {
+    return current;
+}
+export function languageName(id) {
+    return LANGUAGES.find((l) => l.id === id)?.name ?? LANGUAGES[0].name;
+}
+/** The text for a key in the current language, with `{name}` replaced from `vars`. */
+export function t(key, vars) {
+    const text = CATALOGS[current]?.[key] ?? en[key];
+    if (!vars)
+        return text;
+    return text.replace(/\{(\w+)\}/g, (whole, name) => (name in vars ? String(vars[name]) : whole));
+}

package/dist/core/local-config.js

@@ -0,0 +1,69 @@
+/**
+ * Applies a project-level config file (.devx.json / .devxrc.json found in the
+ * working directory) on top of the user's own configuration.
+ *
+ * That file comes from the repository, i.e. from whoever wrote the repository, so:
+ *  - harmless tuning (model, limits, theme) is always applied;
+ *  - everything that decides WHERE the conversation and the API key are sent
+ *    (provider, apiKey, baseUrl) or that loosens the permission guard
+ *    (autoApprove, bashAllowlist) is applied only for a workspace the user trusted.
+ *
+ * Without that split a cloned repository could set `baseUrl` to its own server and
+ * receive the user's API key together with the contents of their files.
+ *
+ * Returns the names of the settings that were ignored.
+ */
+export function applyLocalConfig(target, local, trusted) {
+    const ignored = [];
+    if (!local || typeof local !== 'object')
+        return ignored;
+    if (local.model)
+        target.model = local.model;
+    if (local.maxIterations)
+        target.maxIterations = local.maxIterations;
+    if (local.maxContextTokens)
+        target.maxContextTokens = local.maxContextTokens;
+    if (local.dataSaverLimitMB)
+        target.dataSaverLimitMB = local.dataSaverLimitMB;
+    if (local.pureBlackTheme !== undefined)
+        target.pureBlackTheme = local.pureBlackTheme;
+    const elevated = [
+        ['provider', !!local.provider],
+        ['apiKey', !!local.apiKey],
+        ['baseUrl', !!local.baseUrl],
+        ['autoApprove', local.autoApprove !== undefined],
+        ['bashAllowlist', Array.isArray(local.bashAllowlist)],
+        ['hooks', local.hooks !== undefined],
+    ];
+    for (const [key, present] of elevated) {
+        if (!present)
+            continue;
+        if (trusted) {
+            target[key] = local[key];
+        }
+        else {
+            ignored.push(key);
+        }
+    }
+    return ignored;
+}
+/**
+ * Settings that last for one run only and are never written to ~/.devxrc.json.
+ *  - `autoApprove` (YOLO): switched on in the settings or with `--yolo`, it is off again the
+ *    next time devx starts. A mode that skips confirmations should not stay on by accident.
+ *  - `projectMcpTrusted`, `effortOverride`: runtime flags.
+ */
+export const SESSION_ONLY_SETTINGS = ['autoApprove', 'projectMcpTrusted', 'effortOverride'];
+/** The config as it goes to disk: without the settings that last for one run only. */
+export function persistedConfig(config) {
+    const out = { ...config };
+    for (const key of SESSION_ONLY_SETTINGS)
+        delete out[key];
+    return out;
+}
+/** The config as it was read from disk: a value left there by an older version is dropped. */
+export function withoutSessionOnlySettings(config) {
+    const out = { ...config };
+    delete out.autoApprove;
+    return out;
+}