termux-dev 1.8.2 → 1.9.1

package/dist/cli/updater.js

@@ -1,13 +1,11 @@
-import { execSync, spawn } from 'child_process';
+import { spawn } from 'child_process';
 import path from 'path';
 import fs from 'fs/promises';
-import pc from 'picocolors';
-import { select } from '@inquirer/prompts';
-import { palette } from './ui.js';
 import { fileURLToPath } from 'url';
 const GITHUB_REPO_URL = 'https://github.com/apvcode/Termux-Dev';
-const REMOTE_PKG_URL = 'https://raw.githubusercontent.com/apvcode/Termux-Dev/main/package.json';
-const REMOTE_RELEASE_URL = 'https://api.github.com/repos/apvcode/Termux-Dev/releases/latest';
+// Where to look for the newest version. Overridable (a mirror, a test server).
+const REMOTE_PKG_URL = process.env.DEVX_UPDATE_PKG_URL || 'https://raw.githubusercontent.com/apvcode/Termux-Dev/main/package.json';
+const REMOTE_RELEASE_URL = process.env.DEVX_UPDATE_RELEASE_URL || 'https://api.github.com/repos/apvcode/Termux-Dev/releases/latest';
 // Compare semantic versions (e.g. 1.1.0 > 1.0.0)
 export function isNewerVersion(remote, current) {
     const clean = (v) => v.replace(/^v/, '').trim();
@@ -54,6 +52,7 @@ export async function checkForUpdates(timeoutMs = 10000) {
         });
         let latestVersion = '';
         let releaseNotes = '';
+        let publishedAt = '';
         if (res.ok) {
             const pkg = await res.json();
             latestVersion = (pkg.version || '').replace(/^v/, '').trim();
@@ -71,6 +70,7 @@ export async function checkForUpdates(timeoutMs = 10000) {
                     latestVersion = relTag;
                 }
                 releaseNotes = relData.body || '';
+                publishedAt = relData.published_at || '';
             }
         }
         catch { }
@@ -79,7 +79,8 @@ export async function checkForUpdates(timeoutMs = 10000) {
                 updateAvailable: true,
                 currentVersion,
                 latestVersion,
-                releaseNotes
+                releaseNotes,
+                publishedAt: publishedAt || undefined
             };
         }
         return {
@@ -98,163 +99,136 @@ export async function checkForUpdates(timeoutMs = 10000) {
         };
     }
 }
-async function isGitRepository(dir) {
+/** How this devx was installed: from the npm package, or from a git clone (a developer's copy). */
+export async function detectInstallMethod() {
+    const here = fileURLToPath(import.meta.url);
+    const root = path.resolve(path.dirname(here), '../../');
+    // DEVX_UPDATE_METHOD forces one of them (a copy in a git folder that is installed with npm, a test).
+    const forced = (process.env.DEVX_UPDATE_METHOD || '').toLowerCase();
+    if (forced === 'npm' || forced === 'git')
+        return { method: forced, root };
     try {
-        await fs.stat(path.join(dir, '.git'));
-        return true;
+        await fs.stat(path.join(root, '.git'));
+        return { method: 'git', root };
     }
     catch {
-        return false;
+        return { method: 'npm', root };
     }
 }
-export async function performSelfUpdate(latestVersion) {
-    const __filename = fileURLToPath(import.meta.url);
-    const projectRoot = path.resolve(path.dirname(__filename), '../../');
-    const isGit = await isGitRepository(projectRoot);
-    console.log('\n' + pc.bold(pc.cyan('─── Starting devx Update ──────────────────────────')));
-    if (!isGit) {
-        // 1. Installed via global npm package: termux-dev
-        process.stdout.write(`  ${pc.cyan('›')} [1/1] ${pc.white(`Updating termux-dev via npm (v${latestVersion})...`)}\n`);
-        const frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
-        let fIdx = 0;
-        const interval = setInterval(() => {
-            process.stdout.write(`\r  ${pc.cyan(frames[fIdx++ % frames.length])} ${pc.dim(`npm install -g termux-dev@latest`)} `);
-        }, 80);
-        try {
-            execSync('npm install -g termux-dev@latest --prefer-online', { stdio: 'pipe' });
-            clearInterval(interval);
-            process.stdout.write(`\r  ${pc.green('✓')} ${pc.bold(pc.white(`Successfully updated termux-dev to v${latestVersion} via npm!`))}\n`);
-        }
-        catch (err) {
-            clearInterval(interval);
-            process.stdout.write(`\r  ${pc.red('✖')} ${pc.red(`Update failed: ${err.message}`)}\n`);
-            console.log(pc.yellow(`\nTo update manually, run: ${pc.bold('npm install -g termux-dev@latest')}`));
-            return false;
-        }
+/** What a step of the update says when it fails. `not-published`: the version is on GitHub but not in npm yet. */
+export class UpdateError extends Error {
+    kind;
+    constructor(message, kind = 'failed') {
+        super(message);
+        this.kind = kind;
+        this.name = 'UpdateError';
     }
-    else {
-        // 2. Installed via git clone (Developer mode)
-        const steps = [
+}
+const OUTPUT_KEEP = 4000;
+export const runCommand = (command, args, options = {}) => new Promise((resolve) => {
+    let output = '';
+    const keep = (chunk) => {
+        output = (output + chunk.toString('utf8')).slice(-OUTPUT_KEEP);
+    };
+    // On Windows npm is a .cmd file, which only a shell can start.
+    const child = spawn(command, args, { cwd: options.cwd, shell: process.platform === 'win32', stdio: ['ignore', 'pipe', 'pipe'], windowsHide: true });
+    child.stdout?.on('data', keep);
+    child.stderr?.on('data', keep);
+    child.on('error', (err) => resolve({ code: -1, output: output + String(err.message) }));
+    child.on('close', (code) => resolve({ code: code ?? -1, output }));
+});
+/** The last lines of a command's output, for the message of a failure. */
+export function tail(output, lines = 4) {
+    return output
+        .split('\n')
+        .map((l) => l.trim())
+        .filter(Boolean)
+        .slice(-lines)
+        .join('\n');
+}
+function must(result, what) {
+    if (result.code !== 0)
+        throw new UpdateError(tail(result.output) || `${what} failed (exit code ${result.code})`);
+    return result;
+}
+/**
+ * The steps of an update, in order. Nothing is run until `run()` of a step is called.
+ *
+ *  npm: ask the registry whether the version is there (GitHub knows a release before npm has the
+ *       package: installing `latest` then would "update" to the old version), install exactly that
+ *       version, and read back which version is installed.
+ *  git: pull, install and build, link the command.
+ */
+export function buildUpdateSteps(method, root, version, run = runCommand) {
+    if (method === 'npm') {
+        return [
             {
-                title: 'Pulling latest updates from GitHub repository...',
-                action: () => {
-                    execSync('git pull origin main', { cwd: projectRoot, stdio: 'pipe' });
-                }
+                id: 'registry',
+                run: async () => {
+                    const res = await run('npm', ['view', `termux-dev@${version}`, 'version', '--prefer-online']);
+                    if (res.code !== 0) {
+                        // A version that is not in the registry is an E404, not an older answer.
+                        if (/E404|No match found/i.test(res.output))
+                            throw new UpdateError(`termux-dev@${version} is not in the npm registry yet`, 'not-published');
+                        throw new UpdateError(tail(res.output) || `npm view failed (exit code ${res.code})`);
+                    }
+                    if (res.output.trim().split('\n').pop()?.trim() !== version) {
+                        throw new UpdateError(`termux-dev@${version} is not in the npm registry yet`, 'not-published');
+                    }
+                },
             },
             {
-                title: 'Building and compiling TypeScript sources...',
-                action: () => {
-                    execSync('npm install', { cwd: projectRoot, stdio: 'pipe' });
-                    execSync('npm run build', { cwd: projectRoot, stdio: 'pipe' });
-                }
+                id: 'install',
+                run: async () => {
+                    must(await run('npm', ['install', '-g', `termux-dev@${version}`, '--prefer-online']), 'npm install');
+                },
             },
             {
-                title: 'Ensuring binary execution permissions & linking...',
-                action: () => {
+                id: 'verify',
+                run: async () => {
+                    const res = await run('npm', ['ls', '-g', 'termux-dev', '--depth=0', '--json']);
+                    let installed = '';
                     try {
-                        execSync('npm link', { cwd: projectRoot, stdio: 'pipe' });
+                        installed = JSON.parse(res.output.slice(res.output.indexOf('{')))?.dependencies?.['termux-dev']?.version ?? '';
                     }
                     catch { }
-                }
-            }
+                    if (installed !== version)
+                        throw new UpdateError(`npm reports ${installed || 'no version'} instead of ${version}`);
+                },
+            },
         ];
-        for (let i = 0; i < steps.length; i++) {
-            const step = steps[i];
-            process.stdout.write(`  ${pc.cyan('›')} [${i + 1}/${steps.length}] ${pc.white(step.title)}\n`);
-            const frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
-            let fIdx = 0;
-            const interval = setInterval(() => {
-                process.stdout.write(`\r  ${pc.cyan(frames[fIdx++ % frames.length])} ${pc.dim(step.title)} `);
-            }, 80);
-            try {
-                await new Promise(resolve => setTimeout(resolve, 200));
-                step.action();
-                clearInterval(interval);
-                process.stdout.write(`\r  ${pc.green('✓')} ${pc.bold(pc.white(step.title))}\n`);
-            }
-            catch (err) {
-                clearInterval(interval);
-                process.stdout.write(`\r  ${pc.red('✖')} ${pc.red(step.title)} - ${err.message}\n`);
-                console.log(pc.red(`\nUpdate failed during step ${i + 1}: ${err.message}`));
-                console.log(pc.yellow(`\nTo update manually, run: ${pc.bold('npm install -g termux-dev')}`));
-                return false;
-            }
-        }
-    }
-    console.log(pc.bold(pc.green(`\nSuccessfully updated to v${latestVersion}! Restarting devx...\n`)));
-    console.log(pc.bold(pc.cyan('──────────────────────────────────────────────────────\n')));
-    await new Promise(r => setTimeout(r, 1000));
-    try {
-        const child = spawn(process.argv[0], process.argv.slice(1), {
-            stdio: 'inherit',
-            detached: true
-        });
-        child.unref();
-        process.exit(0);
-    }
-    catch {
-        process.exit(0);
     }
-    return true;
+    return [
+        { id: 'pull', run: async () => void must(await run('git', ['pull', '--ff-only', 'origin', 'main'], { cwd: root }), 'git pull') },
+        {
+            id: 'build',
+            run: async () => {
+                must(await run('npm', ['install'], { cwd: root }), 'npm install');
+                must(await run('npm', ['run', 'build'], { cwd: root }), 'npm run build');
+            },
+        },
+        // Linking is a convenience: a failure here does not undo the update.
+        { id: 'link', run: async () => void (await run('npm', ['link'], { cwd: root })) },
+    ];
 }
-export async function runStartupUpdateCheck(config) {
-    // If updates checking is disabled in settings, return immediately
-    if (config.checkUpdates === false) {
-        return;
-    }
-    const currentVersion = await getCurrentVersion();
-    const frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
-    let fIdx = 0;
-    let isDone = false;
-    const spinner = setInterval(() => {
-        if (isDone)
-            return;
-        // The colours of the theme, like the rest of the interface.
-        const frame = palette.accent(frames[fIdx++ % frames.length]);
-        process.stdout.write(`\r  ${frame} ${palette.muted('Checking for updates from')} ${palette.accent('apvcode/Termux-Dev')} ${palette.faint(`(v${currentVersion})...`)} `);
-    }, 75);
-    const result = await checkForUpdates(10000);
-    isDone = true;
-    clearInterval(spinner);
-    // Clear spinner line
-    process.stdout.write('\r\x1b[K');
-    if (result.updateAvailable) {
-        console.log();
-        console.log(palette.rule('  ┌───────────────────────────────────────────────────────────┐'));
-        console.log(palette.rule('  │') + palette.bold(palette.accent(`  A new update is available: `)) + palette.muted(`v${result.currentVersion}`) + palette.bold(palette.ok(` → v${result.latestVersion}`)) + ' '.repeat(Math.max(1, 23 - result.currentVersion.length - result.latestVersion.length)) + palette.rule('│'));
-        console.log(palette.rule('  │') + palette.faint(`  Repository: https://github.com/apvcode/Termux-Dev          `) + palette.rule('│'));
-        console.log(palette.rule('  └───────────────────────────────────────────────────────────┘'));
-        console.log();
+/** Runs the steps one after the other and stops at the first that fails. */
+export async function runUpdateSteps(steps, events = {}, now = Date.now) {
+    for (let index = 0; index < steps.length; index++) {
+        events.onStart?.(index);
+        const started = now();
         try {
-            const choice = await select({
-                message: palette.bold('Do you want to update devx now?'),
-                loop: false,
-                choices: [
-                    {
-                        name: `Update now (Pull v${result.latestVersion}, rebuild & restart)`,
-                        value: 'update',
-                        description: 'Download latest code, compile TypeScript, and restart devx'
-                    },
-                    {
-                        name: 'Skip for now (Continue to chat)',
-                        value: 'skip',
-                        description: 'Keep current version and start session'
-                    }
-                ]
-            });
-            if (choice === 'update') {
-                await performSelfUpdate(result.latestVersion);
-            }
+            await steps[index].run();
         }
-        catch {
-            // If user presses Ctrl+C / cancels prompt, continue
+        catch (err) {
+            return { ok: false, index, error: err instanceof UpdateError ? err : new UpdateError(String(err?.message || err)) };
         }
+        events.onDone?.(index, now() - started);
     }
-    else {
-        // Briefly show up to date message
-        process.stdout.write(`  ${palette.ok('✓')} ${palette.muted(`devx is up to date (v${result.currentVersion})`)}\n`);
-        await new Promise(r => setTimeout(r, 450));
-        // Clean up line
-        process.stdout.write('\x1b[1A\x1b[2K');
-    }
+    return { ok: true };
+}
+/** Starts devx again, with the same arguments, and ends this process when the new one ends. */
+export function restartDevx() {
+    const child = spawn(process.argv[0], process.argv.slice(1), { stdio: 'inherit' });
+    child.on('exit', (code) => process.exit(code ?? 0));
+    child.on('error', () => process.exit(0));
 }

package/dist/cli/usage-panel.js

@@ -128,10 +128,23 @@ function buildRows(d, iw, detail) {
     const note = costNote(s);
     if (note && detail === 'full')
         line('  ' + palette.faint(truncateWidth(note, iw - 2)));
+    if (s.restoredCost && detail === 'full') {
+        line('  ' + palette.faint(truncateWidth(`Includes ${formatMoney(s.restoredCost, { estimated: s.costState.estimated })} from before this chat was resumed; the lines below count only since devx started.`, iw - 2)));
+    }
     const tokens = iw >= 40 ? `${fmtTokens(s.promptTokens)} in · ${fmtTokens(s.completionTokens)} out` : `${fmtTokens(s.promptTokens)}/${fmtTokens(s.completionTokens)}`;
     pair('Tokens', palette.text(tokens));
-    if (s.cacheReadTokens > 0 && detail !== 'min')
-        pair('Cached input', palette.text(fmtTokens(s.cacheReadTokens)));
+    if (detail !== 'min') {
+        // What the money was paid for. Every request resends the whole conversation, so the input
+        // is usually the biggest part, and the cache is what makes it cheaper.
+        const money = (v) => s.costParts && v !== undefined && iw >= 40 ? palette.faint('  ' + formatMoney(v, { estimated: s.costState.estimated })) : '';
+        const paid = (label, tokens, v) => pair(label, palette.text(fmtTokens(tokens)) + money(v));
+        paid('  Input', s.uncachedTokens, s.costParts?.input);
+        if (s.cacheReadTokens > 0)
+            paid('  Cached input', s.cacheReadTokens, s.costParts?.cacheRead);
+        if (s.cacheWriteTokens > 0)
+            paid('  Cache writes', s.cacheWriteTokens, s.costParts?.cacheWrite);
+        paid('  Output', s.completionTokens, s.costParts?.output);
+    }
     pair('Requests', palette.text(String(s.requestsCount)));
     // ── traffic
     if (detail === 'full') {
@@ -221,7 +234,7 @@ export function runUsagePanel(data, options = {}) {
                 return;
             closed = true;
             input.off('data', onData);
-            output.off?.('resize', draw);
+            stopWatching();
             block.erase();
             if (!wasRaw)
                 input.setRawMode?.(false);
@@ -236,7 +249,7 @@ export function runUsagePanel(data, options = {}) {
             }
         };
         input.on('data', onData);
-        output.on?.('resize', draw);
+        const stopWatching = block.watchResize(draw);
         draw();
     });
 }

package/dist/cli/width.js

@@ -176,3 +176,21 @@ export function wrapText(text, width) {
     const unbreakable = text.split(/\s+/).some((word) => displayWidth(word) > width);
     return unbreakable ? wrapWidth(text, width) : wrapWords(text, width);
 }
+/**
+ * How many rows up the top of a block is from the cursor, once the terminal is `cols` wide.
+ *
+ * A block drawn at one width is re-wrapped by the terminal when the window is resized: a line that
+ * was as wide as the old window now takes several rows, so counting the lines of the block is not
+ * enough to get back to its top (the top stays on screen and the block shows up twice).
+ *
+ * @param lineWidths visible width of each line of the block as it was drawn
+ * @param cursorRow  the line the cursor is on
+ * @param cursorCol  the column of the cursor in that line
+ */
+export function rowsToTop(lineWidths, cursorRow, cursorCol, cols) {
+    const width = Math.max(1, cols);
+    let rows = 0;
+    for (let i = 0; i < cursorRow && i < lineWidths.length; i++)
+        rows += Math.max(1, Math.ceil(lineWidths[i] / width));
+    return rows + Math.floor(Math.max(0, cursorCol) / width);
+}

package/dist/core/background.js

@@ -236,8 +236,22 @@ export class BackgroundManager extends EventEmitter {
             return '';
         const text = this.notes.map((n) => n.text).join('\n\n');
         this.notes = [];
+        // What the prompt frame shows about unreported news is gone now: let it redraw.
+        this.emit('change');
         return `[devx · background tasks]\n${text}`;
     }
+    /**
+     * Tasks that ended badly and whose news the model has not received yet. The prompt frame shows
+     * this number: it goes away once devx has told the model about the failure.
+     */
+    unreportedFailures() {
+        const ids = new Set();
+        for (const note of this.notes) {
+            if (note.kind === 'exit' && this.tasks.get(note.taskId)?.info.status === 'failed')
+                ids.add(note.taskId);
+        }
+        return ids.size;
+    }
     // ───────────────────────── internals ─────────────────────────
     must(id) {
         const task = this.tasks.get(String(id));

package/dist/core/context-stats.js

@@ -23,6 +23,7 @@ export function contextBreakdown(messages, definitions, limit) {
         user, assistant, toolResults,
         images, imageCount,
         total,
+        inUse: messages.some((m) => m.role !== 'system') ? total : 0,
         compactAt: Math.floor(limit * CONTEXT_USAGE_RATIO),
         free: Math.max(0, limit - total),
     };

package/dist/core/cost.js

@@ -12,8 +12,8 @@
  */
 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) {
+/** The cost of the tokens at the given rates, split by what was paid for. */
+export function costParts(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;
@@ -23,17 +23,31 @@ export function computeCost(rates, usage) {
     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;
+    const out = rates.reasoning !== undefined && reasoning > 0
+        ? (completion - reasoning) * output + reasoning * rates.reasoning
+        : completion * output;
+    // Without a cache price the cached tokens cost as much as ordinary input.
+    return {
+        input: (plain * input) / PER_MILLION,
+        cacheRead: (read * (cacheRead ?? input)) / PER_MILLION,
+        cacheWrite: (written * (cacheWrite ?? input)) / PER_MILLION,
+        output: out / PER_MILLION,
+    };
+}
+/** The cost of the tokens at the given rates. */
+export function computeCost(rates, usage) {
+    const p = costParts(rates, usage);
+    return p.input + p.cacheRead + p.cacheWrite + p.output;
+}
+/** The same parts scaled so that they add up to `total` (the cost the provider reported). */
+export function scaleParts(parts, total) {
+    const sum = parts.input + parts.cacheRead + parts.cacheWrite + parts.output;
+    if (!(sum > 0) || !Number.isFinite(total))
+        return undefined;
+    const k = total / sum;
+    return { input: parts.input * k, cacheRead: parts.cacheRead * k, cacheWrite: parts.cacheWrite * k, output: parts.output * k };
 }
 /** A price as the OpenRouter list writes it: USD per token, often a string. */
 function perToken(value) {

package/dist/core/custom-providers.js

@@ -0,0 +1,161 @@
+import { isLocalBaseUrl } from './cost.js';
+/** The key stored for a server that needs none (a local one): the OpenAI client wants some value and falls back to $OPENAI_API_KEY for an empty one. */
+export const NO_KEY = 'no-key';
+/** The id the old single "Custom" entry of the provider list had. */
+const LEGACY_ID = 'custom';
+const MAX_NAME = 40;
+export function customProviders(config) {
+    const own = config.customProviders;
+    return own && typeof own === 'object' && !Array.isArray(own) ? own : {};
+}
+/** The saved providers, in the order they were added. */
+export function listCustomProviders(config) {
+    return Object.entries(customProviders(config))
+        .filter(([, p]) => p && typeof p.baseUrl === 'string')
+        .map(([id, p]) => ({ id, name: String(p.name || id), baseUrl: p.baseUrl, apiKey: config.apiKeys?.[id] ?? '' }));
+}
+export function isCustomProvider(config, id) {
+    return !!id && !!customProviders(config)[id];
+}
+/** The name to show for a provider id: the user's name for a custom one, the label of a listed one, else the id. */
+export function providerDisplayName(config, id, listed = []) {
+    if (!id)
+        return '';
+    const own = customProviders(config)[id];
+    if (own?.name)
+        return own.name;
+    return listed.find((p) => p.value === id)?.label ?? id;
+}
+/**
+ * The single "Custom" entry older versions had becomes a saved provider named Custom, so that
+ * whoever used it finds it in the list (with its address and key). Returns true when it did.
+ */
+export function migrateLegacyCustom(config) {
+    if (customProviders(config)[LEGACY_ID])
+        return false;
+    const url = config.baseUrls?.[LEGACY_ID] || (config.provider === LEGACY_ID ? config.baseUrl : '');
+    if (!url)
+        return false;
+    config.customProviders = { ...customProviders(config), [LEGACY_ID]: { name: 'Custom', baseUrl: url } };
+    return true;
+}
+/** Is this name usable? A name must be unique (without regard to case), but a provider may keep its own. */
+export function nameProblem(config, name, exceptId) {
+    const clean = name.trim();
+    if (!clean)
+        return 'empty';
+    if (Array.from(clean).length > MAX_NAME)
+        return 'long';
+    const taken = listCustomProviders(config).some((p) => p.id !== exceptId && p.name.trim().toLowerCase() === clean.toLowerCase());
+    return taken ? 'taken' : null;
+}
+/** An address of an API: http(s), with a host. The path stays as typed (`/v1`), only a trailing slash goes. */
+export function checkBaseUrl(input) {
+    const text = input.trim();
+    if (!text)
+        return { ok: false, reason: 'empty' };
+    let url;
+    try {
+        url = new URL(text);
+    }
+    catch {
+        return { ok: false, reason: 'invalid' };
+    }
+    if (url.protocol !== 'http:' && url.protocol !== 'https:')
+        return { ok: false, reason: 'scheme' };
+    if (!url.hostname)
+        return { ok: false, reason: 'invalid' };
+    return { ok: true, url: text.replace(/\/+$/, '') };
+}
+/** A server on this machine or on the home network usually needs no key. */
+export function usuallyNeedsNoKey(baseUrl) {
+    return isLocalBaseUrl(baseUrl);
+}
+/** `api.example.com` for the list. */
+export const hostOfUrl = (url) => url.replace(/^https?:\/\//, '').replace(/\/.*$/, '');
+/** The key as the list shows it. */
+export function keyHint(key) {
+    if (!key)
+        return '';
+    if (key === NO_KEY)
+        return 'no key';
+    if (key.length <= 8)
+        return '****';
+    return `${key.slice(0, 4)}...${key.slice(-4)}`;
+}
+// ───────────────────────── changing the saved providers ─────────────────────────
+/** An id from the name that no listed and no saved provider has: `custom-my-gateway`, `custom-my-gateway-2`. */
+export function newProviderId(config, name, listedIds = []) {
+    const slug = name
+        .toLowerCase()
+        .normalize('NFC')
+        .replace(/[^\p{L}\p{N}]+/gu, '-')
+        .replace(/^-+|-+$/g, '')
+        .slice(0, 30) || 'provider';
+    const taken = new Set([...listedIds, ...Object.keys(customProviders(config))]);
+    let id = `custom-${slug}`;
+    for (let n = 2; taken.has(id); n++)
+        id = `custom-${slug}-${n}`;
+    return id;
+}
+function ensureMaps(config) {
+    const own = config.customProviders;
+    if (!own || typeof own !== 'object' || Array.isArray(own))
+        config.customProviders = {};
+    config.apiKeys = config.apiKeys || {};
+    config.baseUrls = config.baseUrls || {};
+}
+/** Adds a provider and returns its id. The name and address are expected to have been checked. */
+export function addCustomProvider(config, input, listedIds = []) {
+    ensureMaps(config);
+    const id = newProviderId(config, input.name, listedIds);
+    config.customProviders[id] = { name: input.name.trim(), baseUrl: input.baseUrl };
+    config.baseUrls[id] = input.baseUrl;
+    config.apiKeys[id] = input.apiKey;
+    return id;
+}
+/**
+ * Changes the name, the address or the key of a saved provider. When it is the provider in use,
+ * the settings of the running session follow at once.
+ */
+export function updateCustomProvider(config, id, patch) {
+    const own = customProviders(config)[id];
+    if (!own)
+        return false;
+    ensureMaps(config);
+    if (patch.name !== undefined)
+        config.customProviders[id] = { ...config.customProviders[id], name: patch.name.trim() };
+    if (patch.baseUrl !== undefined) {
+        config.customProviders[id] = { ...config.customProviders[id], baseUrl: patch.baseUrl };
+        config.baseUrls[id] = patch.baseUrl;
+        if (config.provider === id)
+            config.baseUrl = patch.baseUrl;
+    }
+    if (patch.apiKey !== undefined) {
+        config.apiKeys[id] = patch.apiKey;
+        if (config.provider === id)
+            config.apiKey = patch.apiKey;
+    }
+    return true;
+}
+/**
+ * Forgets a saved provider with its key. The provider in use keeps working until another is chosen
+ * (its address and key stay in the running settings) but it is no longer a provider of the list:
+ * the config forgets its id, so that saving does not write the key and the address back;
+ * `wasActive` tells the caller to say so.
+ */
+export function removeCustomProvider(config, id) {
+    if (!customProviders(config)[id])
+        return { removed: false, wasActive: false };
+    const rest = { ...config.customProviders };
+    delete rest[id];
+    config.customProviders = rest;
+    if (config.apiKeys)
+        delete config.apiKeys[id];
+    if (config.baseUrls)
+        delete config.baseUrls[id];
+    const wasActive = config.provider === id;
+    if (wasActive)
+        delete config.provider;
+    return { removed: true, wasActive };
+}