zerogterm 0.7.0-alpha2 → 0.7.0-alpha3

package/dist/main/main/ai-service.js

@@ -0,0 +1,148 @@
+// The request to an OpenAI-compatible endpoint.
+//
+// In the main process rather than the renderer, for two reasons. A renderer
+// fetch is a cross-origin request, and Ollama refuses those unless
+// OLLAMA_ORIGINS is set — so the most obvious local setup would fail for a
+// reason the user cannot see. And the API key never has to enter the renderer at
+// all: it is read here, used for one request, and not held.
+//
+// Bounded and cancellable, as CONTEXT.md asks of AI output capture: every call
+// carries an AbortController and a timeout, so a server that accepts a
+// connection and then says nothing cannot leave a dialog waiting forever.
+import { AI_TIMEOUT_MS, ERROR_BODY_CHARS, buildSuggestionRequest, chatCompletionsUrl, modelsUrl, parseModelList, parseSuggestion } from './ai-protocol.js';
+import { isSupportedEndpoint } from '../shared/endpoints.js';
+export class AiService {
+    readApiKey;
+    fetchImpl;
+    timeoutMs;
+    /** The request in flight, so a new one supersedes it rather than racing it. */
+    inFlight = null;
+    constructor(options) {
+        this.readApiKey = options.readApiKey;
+        this.fetchImpl = options.fetch ?? ((url, init) => fetch(url, init));
+        this.timeoutMs = options.timeoutMs ?? AI_TIMEOUT_MS;
+    }
+    /** Abandon whatever is in flight. The dialog closing is a reason to. */
+    cancel() {
+        this.inFlight?.abort();
+        this.inFlight = null;
+    }
+    async suggest(config, request) {
+        requireEndpoint(config.baseUrl);
+        const body = buildSuggestionRequest({
+            prompt: request.prompt,
+            model: config.model,
+            context: request.context
+        });
+        // Only one suggestion is ever wanted at a time, and the old one's answer
+        // would arrive against a dialog that has moved on.
+        this.cancel();
+        const controller = new AbortController();
+        this.inFlight = controller;
+        try {
+            const payload = await this.send(chatCompletionsUrl(config.baseUrl), body, controller);
+            return parseSuggestion(payload);
+        }
+        finally {
+            if (this.inFlight === controller)
+                this.inFlight = null;
+        }
+    }
+    async listModels(baseUrl) {
+        requireEndpoint(baseUrl);
+        const controller = new AbortController();
+        const payload = await this.send(modelsUrl(baseUrl), undefined, controller);
+        return parseModelList(payload);
+    }
+    /**
+     * Ask the endpoint for one token, and report what happened in a sentence.
+     *
+     * A real completion rather than a reachability check: a server can accept a
+     * connection, list models, and still refuse to run the model that is
+     * configured. That is the failure worth catching before the user needs it.
+     */
+    async test(config) {
+        try {
+            requireEndpoint(config.baseUrl);
+            if (!config.model.trim())
+                throw new Error('Choose a model first.');
+            const controller = new AbortController();
+            const payload = await this.send(chatCompletionsUrl(config.baseUrl), { model: config.model.trim(), max_tokens: 8, messages: [{ role: 'user', content: 'Reply with: ok' }] }, controller);
+            const suggestion = parseSuggestion(payload);
+            // A reply that did not parse is still a working endpoint: the test is
+            // whether the model answered, not whether it answered in the shape a
+            // suggestion needs.
+            return { ok: true, message: `${config.model} replied${suggestion.explanation ? `: ${trim(suggestion.explanation)}` : '.'}` };
+        }
+        catch (error) {
+            return { ok: false, message: error instanceof Error ? error.message : String(error) };
+        }
+    }
+    async send(url, body, controller) {
+        const key = await this.readApiKey();
+        const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+        try {
+            const response = await this.fetchImpl(url, {
+                method: body === undefined ? 'GET' : 'POST',
+                headers: {
+                    ...(body === undefined ? {} : { 'Content-Type': 'application/json' }),
+                    // Only when there is one: a local Ollama wants no header at all, and
+                    // an empty Bearer is worse than none.
+                    ...(key ? { Authorization: `Bearer ${key}` } : {})
+                },
+                ...(body === undefined ? {} : { body: JSON.stringify(body) }),
+                signal: controller.signal
+            });
+            if (!response.ok)
+                throw new Error(await describeFailure(response));
+            try {
+                return await response.json();
+            }
+            catch {
+                // A server that answers 200 with HTML is usually a proxy or a wrong
+                // path, and saying so beats "Unexpected token <".
+                throw new Error('The endpoint answered with something other than JSON. Check the base URL ends in /v1.');
+            }
+        }
+        catch (error) {
+            if (error instanceof Error && error.name === 'AbortError') {
+                throw new Error(`The endpoint did not answer within ${Math.round(this.timeoutMs / 1000)}s.`);
+            }
+            if (error instanceof TypeError) {
+                // What fetch throws when nothing is listening, with a message that names
+                // no host and helps nobody.
+                throw new Error(`Could not reach ${url}. Is the server running?`);
+            }
+            throw error;
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+}
+function requireEndpoint(baseUrl) {
+    if (!isSupportedEndpoint(baseUrl)) {
+        throw new Error('Set an http(s) base URL in Settings, such as http://127.0.0.1:11434/v1.');
+    }
+}
+/**
+ * A failing response, as a sentence.
+ *
+ * The status alone does not distinguish a wrong key from a missing model, and
+ * these servers put the difference in the body — so the body is read, trimmed,
+ * and quoted.
+ */
+async function describeFailure(response) {
+    const detail = await response.text().then(trim).catch(() => '');
+    if (response.status === 401 || response.status === 403) {
+        return `The endpoint refused the key (${response.status}).${detail ? ` ${detail}` : ''}`;
+    }
+    if (response.status === 404) {
+        return `Not found (404). Check the base URL ends in /v1 and the model exists.${detail ? ` ${detail}` : ''}`;
+    }
+    return `The endpoint returned ${response.status}.${detail ? ` ${detail}` : ''}`;
+}
+function trim(text) {
+    const clean = text.replace(/\s+/g, ' ').trim();
+    return clean.length > ERROR_BODY_CHARS ? `${clean.slice(0, ERROR_BODY_CHARS - 1)}…` : clean;
+}

package/dist/main/main/command-history-store.js

@@ -0,0 +1,231 @@
+import { mkdir, readFile, rename, unlink, writeFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { randomUUID } from 'node:crypto';
+const SCHEMA_VERSION = 1;
+/**
+ * How many commands to keep.
+ *
+ * Large enough that a month of work fits, small enough that the whole file is
+ * read, ranked and written in memory without anyone noticing. JSON per
+ * CONTEXT.md's answered question 7; SQLite remains the option that doc says it
+ * is, if this ceiling ever becomes the thing that hurts.
+ */
+const MAX_ENTRIES = 5000;
+const MAX_COMMAND_CHARS = 1000;
+/**
+ * The command history on disk.
+ *
+ * The only ZeroG store that holds what the user typed, which is why it is off
+ * until asked for and why nothing reaches it that has not been through
+ * command-redaction. That check runs in the renderer, next to the capture; this
+ * side enforces the shape and the ceiling.
+ */
+export class CommandHistoryStore {
+    filePath;
+    file = { version: SCHEMA_VERSION, entries: [] };
+    loaded = false;
+    writeQueue = Promise.resolve();
+    constructor(options) {
+        this.filePath = options.filePath;
+        this.now = options.now ?? (() => new Date());
+    }
+    now;
+    async list() {
+        await this.ensureLoaded();
+        return this.file.entries.map((entry) => ({ ...entry }));
+    }
+    /**
+     * Record a run, or note another one of something already known.
+     *
+     * Upserted on command *and* directory, so `runs` counts what it says it does
+     * and the directory a command belongs to is not overwritten by the next place
+     * it happens to be typed.
+     */
+    async record(input) {
+        await this.ensureLoaded();
+        const command = safeText(input.command, MAX_COMMAND_CHARS);
+        if (!command)
+            return null;
+        const cwd = optionalText(input.cwd, 1024);
+        const existing = this.file.entries.find((entry) => entry.command === command && entry.cwd === cwd);
+        const lastRun = this.now().toISOString();
+        if (existing) {
+            existing.runs += 1;
+            existing.lastRun = lastRun;
+            // The latest outcome replaces the last, including replacing a known status
+            // with none: a command that used to work and now reports nothing should
+            // not keep claiming success.
+            if (input.exitCode === undefined)
+                delete existing.exitCode;
+            else
+                existing.exitCode = input.exitCode;
+            await this.persist();
+            return { ...existing };
+        }
+        const entry = {
+            id: `cmd:${randomUUID()}`,
+            command,
+            ...(cwd ? { cwd } : {}),
+            ...(optionalText(input.host, 256) ? { host: String(input.host) } : {}),
+            ...(input.kind === 'ssh' || input.kind === 'local' ? { kind: input.kind } : {}),
+            ...(input.exitCode === undefined ? {} : { exitCode: input.exitCode }),
+            lastRun,
+            runs: 1,
+            picks: 0
+        };
+        this.file.entries.push(entry);
+        this.evict();
+        await this.persist();
+        return { ...entry };
+    }
+    /**
+     * Note that an entry was chosen from the palette.
+     *
+     * McFly's most useful signal, and the reason the ranking improves with use:
+     * being picked says more about what someone wants than being run does, because
+     * running happens by habit and picking happens on purpose.
+     */
+    async pick(id) {
+        await this.ensureLoaded();
+        const entry = this.file.entries.find((candidate) => candidate.id === id);
+        if (!entry)
+            return;
+        entry.picks += 1;
+        entry.lastRun = this.now().toISOString();
+        await this.persist();
+    }
+    /** Forget everything, and take the file with it. */
+    async clear() {
+        this.loaded = true;
+        this.file = { version: SCHEMA_VERSION, entries: [] };
+        // Emptied *and* removed: a file left holding `{"entries":[]}` looks like a
+        // feature still running, and "clear my history" should leave nothing behind.
+        this.writeQueue = this.writeQueue.then(async () => {
+            try {
+                await unlink(this.filePath);
+            }
+            catch {
+                /* never existed */
+            }
+        });
+        await this.writeQueue;
+    }
+    /**
+     * Drop the least valuable entries once over the ceiling.
+     *
+     * Least recently run goes first, but anything ever picked from the palette is
+     * kept ahead of anything never picked: a command someone deliberately chose
+     * three weeks ago is worth more than one that scrolled past yesterday.
+     */
+    evict() {
+        if (this.file.entries.length <= MAX_ENTRIES)
+            return;
+        const ranked = [...this.file.entries].sort((a, b) => {
+            if ((a.picks > 0) !== (b.picks > 0))
+                return a.picks > 0 ? -1 : 1;
+            return b.lastRun.localeCompare(a.lastRun);
+        });
+        this.file.entries = ranked.slice(0, MAX_ENTRIES);
+    }
+    async ensureLoaded() {
+        if (this.loaded)
+            return;
+        this.loaded = true;
+        try {
+            const parsed = JSON.parse(await readFile(this.filePath, 'utf8'));
+            const normalized = normalizeFile(parsed);
+            if (normalized)
+                this.file = normalized;
+        }
+        catch {
+            this.file = { version: SCHEMA_VERSION, entries: [] };
+        }
+    }
+    async persist() {
+        const snapshot = this.file;
+        this.writeQueue = this.writeQueue.then(async () => {
+            try {
+                await mkdir(dirname(this.filePath), { recursive: true });
+                const temp = join(dirname(this.filePath), `.command-history.tmp-${process.pid}-${randomUUID()}`);
+                await writeFile(temp, JSON.stringify(snapshot, null, 1), { encoding: 'utf8', mode: 0o600 });
+                await rename(temp, this.filePath);
+            }
+            catch {
+                // History must never affect terminal operation.
+            }
+        });
+        await this.writeQueue;
+    }
+}
+/** Strip control characters and cap length; the file is user-editable. */
+function safeText(value, limit) {
+    if (typeof value !== 'string')
+        return '';
+    return value.replace(CONTROL_CHARACTERS, '').trim().slice(0, limit);
+}
+function optionalText(value, limit) {
+    const text = safeText(value, limit);
+    return text ? text : undefined;
+}
+// Built from character codes rather than a regex literal: a control character
+// inside a literal is invisible in the source and easily destroyed by a later
+// edit. remote-screens.ts does the same, for the same reason.
+const CONTROL_CHARACTERS = new RegExp('[' + String.fromCharCode(0) + '-' + String.fromCharCode(31) + String.fromCharCode(127) + ']', 'g');
+function normalizeEntry(value) {
+    if (!value || typeof value !== 'object')
+        return undefined;
+    const item = value;
+    const id = safeText(item.id, 64);
+    const command = safeText(item.command, MAX_COMMAND_CHARS);
+    const lastRun = safeText(item.lastRun, 40);
+    if (!id || !command || !Number.isFinite(Date.parse(lastRun)))
+        return undefined;
+    const entry = {
+        id,
+        command,
+        lastRun: new Date(Date.parse(lastRun)).toISOString(),
+        runs: count(item.runs, 1),
+        picks: count(item.picks, 0)
+    };
+    const cwd = optionalText(item.cwd, 1024);
+    const host = optionalText(item.host, 256);
+    if (cwd)
+        entry.cwd = cwd;
+    if (host)
+        entry.host = host;
+    if (item.kind === 'ssh' || item.kind === 'local')
+        entry.kind = item.kind;
+    if (typeof item.exitCode === 'number' && Number.isInteger(item.exitCode) && item.exitCode >= 0 && item.exitCode <= 255) {
+        entry.exitCode = item.exitCode;
+    }
+    return entry;
+}
+function count(value, fallback) {
+    if (typeof value !== 'number' || !Number.isInteger(value) || value < 0)
+        return fallback;
+    return Math.min(value, Number.MAX_SAFE_INTEGER);
+}
+export function normalizeFile(value) {
+    if (!value || typeof value !== 'object')
+        return undefined;
+    const item = value;
+    if (item.version !== SCHEMA_VERSION)
+        return undefined;
+    if (!Array.isArray(item.entries))
+        return undefined;
+    const entries = [];
+    const seen = new Set();
+    for (const raw of item.entries) {
+        const entry = normalizeEntry(raw);
+        if (!entry || seen.has(entry.id))
+            continue;
+        seen.add(entry.id);
+        entries.push(entry);
+        if (entries.length >= MAX_ENTRIES)
+            break;
+    }
+    return { version: SCHEMA_VERSION, entries };
+}
+export function defaultCommandHistoryPath(userDataPath) {
+    return join(userDataPath, 'command-history.json');
+}

package/dist/main/main/main.js

@@ -1,21 +1,40 @@
-import { app, BrowserWindow, clipboard, ipcMain, Menu, session, shell } from 'electron';
+import { app, BrowserWindow, clipboard, ipcMain, Menu, safeStorage, session, shell } from 'electron';
 import { join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { writeClipboardText } from './clipboard.js';
 import { ScreenService, parseWslDistributions } from './session-service.js';
 import { discoverShellBackends } from './shell-catalog.js';
 import { SessionHistoryStore, defaultHistoryPath } from './session-history.js';
+import { CommandHistoryStore, defaultCommandHistoryPath } from './command-history-store.js';
+import { WorkspaceStore, defaultWorkspacePath } from './workspace-store.js';
+import { PortForwardService } from './port-forward-service.js';
+import { PortForwardStore, defaultPortForwardPath } from './port-forward-store.js';
 import { buildRemoteScreenAttachArgs, buildRemoteScreenDiscoveryArgs, listKnownConnections, parseRemoteScreenList, validateKnownConnection } from './ssh-inventory.js';
 import { createLocalDirectory, listLocalDirectory, localHome, removeLocalEntry, renameLocalEntry } from './local-fs.js';
+import { wslHomeDirectory } from './wsl-home.js';
 import { decideExternalLink, isApplicationUrl } from './external-links.js';
 import { SftpService } from './sftp-service.js';
+import { AI_API_KEY, SPEECH_API_KEY, SecretStore, defaultSecretsPath } from './secret-store.js';
+import { AiService } from './ai-service.js';
 const __dirname = fileURLToPath(new URL('.', import.meta.url));
 const history = new SessionHistoryStore({ filePath: defaultHistoryPath(app.getPath('userData')) });
+// The only store holding what the user typed. Nothing reaches it that has not
+// been through command-redaction in the renderer, and it holds nothing at all
+// until the setting is turned on.
+const commands = new CommandHistoryStore({ filePath: defaultCommandHistoryPath(app.getPath('userData')) });
+const workspaceStore = new WorkspaceStore({ filePath: defaultWorkspacePath(app.getPath('userData')) });
+const forwardStore = new PortForwardStore({ filePath: defaultPortForwardPath(app.getPath('userData')) });
+// Tunnels outlive the Ports view being closed: authenticating again is a real
+// cost to pay for having looked away.
+const forwards = new PortForwardService({ onEvent: (event) => win?.webContents.send('forwards:event', event) });
 const service = new ScreenService({ onEvent: (event, session, available) => { void history.record(event, session, available); } });
 let win;
 // Transfer connections outlive any single panel opening, so the panel can be
 // closed and reopened without re-authenticating to the host.
 const sftp = new SftpService({ onEvent: (event) => win?.webContents.send('sftp:event', event) });
+// API keys for speech servers. safeStorage is only usable after the app is
+// ready, which every IPC call here already is.
+const secrets = new SecretStore({ filePath: defaultSecretsPath(app.getPath('userData')), crypto: safeStorage });
 /** A pane's measured size, as it arrives from the renderer. */
 function parsePtySize(value) {
     if (!value || typeof value !== 'object')
@@ -91,6 +110,9 @@ function createWindow() {
         win = undefined;
         service.detachAll();
         sftp.closeAll();
+        // A tunnel is a listening socket on someone's machine. It does not outlive
+        // the window that opened it.
+        forwards.closeAll();
     });
 }
 function isRecord(value) {
@@ -128,6 +150,18 @@ ipcMain.handle('links:openExternal', (_event, url) => {
 ipcMain.handle('sessions:list', () => service.list());
 ipcMain.handle('sessions:history', () => history.list());
 ipcMain.handle('sessions:historyRemove', (_event, entryId) => history.remove(entryId));
+ipcMain.handle('commands:list', () => commands.list());
+ipcMain.handle('commands:record', (_event, record) => commands.record(requireCommandRecord(record)));
+ipcMain.handle('commands:pick', (_event, id) => commands.pick(requireString(id, 'A command')));
+ipcMain.handle('commands:clear', () => commands.clear());
+ipcMain.handle('forwards:list', () => forwards.list());
+ipcMain.handle('forwards:open', (_event, request) => forwards.open(requireForwardRequest(request)));
+ipcMain.handle('forwards:close', (_event, id) => forwards.close(requireString(id, 'A shared port')));
+ipcMain.handle('forwards:answerPrompt', (_event, id, answer) => forwards.answerPrompt(requireString(id, 'A shared port'), requireString(answer, 'An answer')));
+ipcMain.handle('forwards:load', () => forwardStore.load());
+ipcMain.handle('forwards:save', (_event, file) => forwardStore.save(file));
+ipcMain.handle('workspaces:load', () => workspaceStore.load());
+ipcMain.handle('workspaces:save', (_event, file) => workspaceStore.save(file));
 ipcMain.handle('sessions:backends', () => discoverShellBackends());
 ipcMain.handle('sessions:wslDistributions', async () => {
     try {
@@ -211,12 +245,100 @@ function requireString(value, field) {
         throw new Error(`${field} is required.`);
     return value;
 }
+/**
+ * A captured command, shaped.
+ *
+ * Only the shape is checked here. Whether the text is safe to store was decided
+ * in the renderer by command-redaction, next to the capture that produced it —
+ * that is where the rules and their tests live.
+ */
+function requireCommandRecord(value) {
+    if (!isRecord(value))
+        throw new Error('A command is required.');
+    const text = (field) => (typeof field === 'string' && field ? field : undefined);
+    return {
+        command: requireString(value.command, 'A command'),
+        ...(text(value.cwd) ? { cwd: String(value.cwd) } : {}),
+        ...(text(value.host) ? { host: String(value.host) } : {}),
+        ...(value.kind === 'ssh' || value.kind === 'local' ? { kind: value.kind } : {}),
+        ...(typeof value.exitCode === 'number' ? { exitCode: value.exitCode } : {})
+    };
+}
+function requireAiConfig(value) {
+    if (!isRecord(value))
+        throw new Error('An AI endpoint is required.');
+    return {
+        baseUrl: typeof value.baseUrl === 'string' ? value.baseUrl : '',
+        model: typeof value.model === 'string' ? value.model : ''
+    };
+}
+/**
+ * A suggestion request, shaped.
+ *
+ * The prompt and the context are checked for type here and for content by
+ * buildSuggestionRequest, which is where those rules are tested. The captured
+ * output is deliberately not inspected: it is untrusted by design, and
+ * ai-protocol is what makes it safe to include.
+ */
+function requireSuggestionRequest(value) {
+    if (!isRecord(value))
+        throw new Error('A request is required.');
+    const context = isRecord(value.context) ? value.context : {};
+    const text = (field) => (typeof field === 'string' && field ? field : undefined);
+    return {
+        prompt: typeof value.prompt === 'string' ? value.prompt : '',
+        ...(text(value.sessionId) ? { sessionId: String(value.sessionId) } : {}),
+        context: {
+            ...(text(context.shell) ? { shell: String(context.shell) } : {}),
+            ...(text(context.cwd) ? { cwd: String(context.cwd) } : {}),
+            ...(text(context.host) ? { host: String(context.host) } : {}),
+            ...(context.kind === 'ssh' || context.kind === 'local' ? { kind: context.kind } : {}),
+            ...(text(context.output) ? { output: String(context.output) } : {})
+        }
+    };
+}
+/**
+ * A forwarding request, shaped.
+ *
+ * Only the shape is checked here: the values are vetted by buildForwardArgs,
+ * which is where the rules live and where they are tested, and which throws a
+ * sentence the renderer can show as-is.
+ */
+function requireForwardRequest(value) {
+    if (!isRecord(value))
+        throw new Error('A shared port is required.');
+    return {
+        target: requireString(value.target, 'An SSH target'),
+        direction: value.direction,
+        bind: value.bind,
+        listenPort: value.listenPort,
+        destinationPort: value.destinationPort,
+        ...(typeof value.destinationHost === 'string' && value.destinationHost ? { destinationHost: value.destinationHost } : {}),
+        ...(typeof value.id === 'string' && value.id ? { id: value.id } : {})
+    };
+}
 function requireEntryKind(value) {
     if (value === 'file' || value === 'directory' || value === 'symlink')
         return value;
     throw new Error('An entry kind of file, directory, or symlink is required.');
 }
+// Electron's own reading of package.json, so the title bar shows what is
+// actually running rather than a string compiled in from the repo.
+ipcMain.handle('app:version', () => app.getVersion());
 ipcMain.handle('fs:localHome', () => localHome());
+// Cached on success only, so a distribution that was not running when it was
+// first asked can answer later.
+const wslHomes = new Map();
+ipcMain.handle('fs:wslHome', async (_event, distribution) => {
+    const name = typeof distribution === 'string' ? distribution : '';
+    const known = wslHomes.get(name);
+    if (known)
+        return known;
+    const home = await wslHomeDirectory(name);
+    if (home)
+        wslHomes.set(name, home);
+    return home;
+});
 ipcMain.handle('fs:listLocal', (_event, path) => listLocalDirectory(typeof path === 'string' && path ? path : undefined));
 ipcMain.handle('fs:mkdirLocal', (_event, path) => createLocalDirectory(requireString(path, 'A folder path')));
 ipcMain.handle('fs:renameLocal', (_event, from, to) => renameLocalEntry(requireString(from, 'The current path'), requireString(to, 'The new path')));
@@ -236,10 +358,39 @@ ipcMain.handle('sftp:answerPrompt', (_event, id, answer) => {
     sftp.answerPrompt(requireString(id, 'A transfer connection'), answer);
 });
 ipcMain.handle('sftp:close', (_event, id) => sftp.close(requireString(id, 'A transfer connection')));
-ipcMain.handle('ai:suggest', () => ({
-    command: 'git status --short',
-    explanation: 'Read-only preview of changed files in the active workspace.'
-}));
+// The key is read here, per request, and never handed to the renderer.
+const ai = new AiService({ readApiKey: () => secrets.get(AI_API_KEY) });
+ipcMain.handle('ai:suggest', (_event, config, request) => ai.suggest(requireAiConfig(config), requireSuggestionRequest(request)));
+ipcMain.handle('ai:models', (_event, baseUrl) => ai.listModels(requireString(baseUrl, 'A base URL')));
+ipcMain.handle('ai:test', (_event, config) => ai.test(requireAiConfig(config)));
+ipcMain.handle('ai:cancel', () => ai.cancel());
+async function aiKeyStatus() {
+    return { stored: await secrets.has(AI_API_KEY), encryptionAvailable: secrets.encryptionAvailable() };
+}
+ipcMain.handle('aiKey:status', () => aiKeyStatus());
+ipcMain.handle('aiKey:save', async (_event, key) => {
+    await secrets.set(AI_API_KEY, typeof key === 'string' ? key.trim() : '');
+    return aiKeyStatus();
+});
+ipcMain.handle('aiKey:clear', async () => {
+    await secrets.clear(AI_API_KEY);
+    return aiKeyStatus();
+});
+async function speechKeyStatus() {
+    return { stored: await secrets.has(SPEECH_API_KEY), encryptionAvailable: secrets.encryptionAvailable() };
+}
+ipcMain.handle('speechKey:status', () => speechKeyStatus());
+ipcMain.handle('speechKey:save', async (_event, key) => {
+    // An empty key means "clear", which SecretStore already does — but the
+    // string still has to be a string, and a pasted key often carries newlines.
+    await secrets.set(SPEECH_API_KEY, typeof key === 'string' ? key.trim() : '');
+    return speechKeyStatus();
+});
+ipcMain.handle('speechKey:clear', async () => {
+    await secrets.clear(SPEECH_API_KEY);
+    return speechKeyStatus();
+});
+ipcMain.handle('speechKey:read', () => secrets.get(SPEECH_API_KEY));
 app.whenReady().then(() => {
     // Voice input captures the local microphone only. Electron denies all
     // permission requests unless a handler answers, so grant media explicitly.