zerogterm 0.7.0-alpha2 → 0.7.0-alpha3

package/dist/main/main/port-forward-protocol.js

@@ -0,0 +1,161 @@
+// Turning a forwarding request into an ssh command line, and reading back
+// whether the tunnel came up.
+//
+// Kept apart from the service so the part that decides what `ssh` is asked to do
+// can be tested exhaustively without spawning anything. That matters more here
+// than usual: every field lands in an argv element, and the whole point of the
+// feature is to open a listening socket.
+import { parseSshTarget, sshExecutable } from './session-service.js';
+import { isSshHostName } from './ssh-inventory.js';
+/** Where traffic goes when the request does not say. */
+const DEFAULT_DESTINATION_HOST = 'localhost';
+/**
+ * How long to wait for a tunnel to declare itself before assuming it is up.
+ *
+ * Only a fallback: an ssh that has authenticated and gone quiet without saying
+ * it started listening is almost certainly listening. The explicit signals in
+ * readForwardOutcome are what normally settle this, and they arrive in
+ * milliseconds.
+ */
+export const FORWARD_SETTLE_MS = 1500;
+function requirePort(value, what) {
+    if (typeof value !== 'number' || !Number.isInteger(value) || value < 1 || value > 65535) {
+        throw new Error(`${what} must be a whole number between 1 and 65535.`);
+    }
+    return value;
+}
+function requireDirection(value) {
+    if (value !== 'local' && value !== 'remote')
+        throw new Error('A forward must be local or remote.');
+    return value;
+}
+function requireBind(value) {
+    if (value !== 'loopback' && value !== 'all')
+        throw new Error('A forward must bind to loopback or to all interfaces.');
+    return value;
+}
+/**
+ * The host on the receiving side of the tunnel.
+ *
+ * Vetted with the same rule as a HostName in ~/.ssh/config, because it is
+ * concatenated into the forward spec — one argv element — and a value beginning
+ * with '-' would be read by ssh's getopt as an option instead.
+ *
+ * Colons are then refused on top of that rule, which a HostName is allowed to
+ * carry for an IPv6 literal. ssh splits a forward spec on colons, so an
+ * unbracketed IPv6 address there does not mean what it looks like: `[::1]` is
+ * the syntax, and accepting a bare `::1` would silently build a spec describing
+ * a different tunnel. Bracketed literals are a separate job, so this says no
+ * rather than guessing.
+ */
+function requireDestinationHost(value) {
+    if (value === undefined || value === '')
+        return DEFAULT_DESTINATION_HOST;
+    if (typeof value !== 'string' || !isSshHostName(value)) {
+        throw new Error('The destination host must be a hostname or IP address.');
+    }
+    if (value.includes(':')) {
+        throw new Error('An IPv6 destination is not supported yet. Use a hostname or an IPv4 address.');
+    }
+    return value;
+}
+/**
+ * The bind address to put in the spec, or nothing.
+ *
+ * The two directions are not symmetric here, and it is the server's rule that
+ * makes them differ. A `-L` forward binds on this machine, so the address is
+ * ours to state and is always stated. A `-R` forward binds on the remote, where
+ * sshd's GatewayPorts decides: the default (`no`) binds loopback and rejects a
+ * client-specified address outright, so loopback has to be expressed by saying
+ * nothing at all. `*` is used for the wide case because it is accepted under
+ * both `yes` and `clientspecified`.
+ */
+function bindPrefix(direction, bind) {
+    if (direction === 'local')
+        return bind === 'all' ? '0.0.0.0:' : '127.0.0.1:';
+    return bind === 'all' ? '*:' : '';
+}
+/**
+ * Build the command line for a forward.
+ *
+ * Two options carry most of the weight:
+ *
+ * `ExitOnForwardFailure=yes` — without it, ssh stays connected when the forward
+ * cannot bind, and there is no way to tell a working tunnel from a useless one
+ * short of trying to use it. With it, a forward that fails is a process that
+ * exits, and the UI can say so.
+ *
+ * `-v` — so that the tunnel being up is something ssh said rather than something
+ * we assumed. `-N` produces no output of its own on success, so without this the
+ * only signal available is the absence of an error.
+ */
+export function buildForwardArgs(request, options = {}) {
+    const direction = requireDirection(request.direction);
+    const bind = requireBind(request.bind);
+    const listenPort = requirePort(request.listenPort, 'The port to open');
+    const destinationPort = requirePort(request.destinationPort, 'The port to forward to');
+    const destinationHost = requireDestinationHost(request.destinationHost);
+    const { destination, port } = parseSshTarget(request.target);
+    const spec = `${bindPrefix(direction, bind)}${listenPort}:${destinationHost}:${destinationPort}`;
+    const args = ['-v', '-N', '-o', 'ExitOnForwardFailure=yes', '-o', 'ConnectTimeout=20'];
+    if (port)
+        args.push('-p', port);
+    args.push(direction === 'local' ? '-L' : '-R', spec);
+    // '--' ends option parsing, so the destination can never be read as a flag.
+    args.push('--', destination);
+    return { file: sshExecutable(options), args, spec };
+}
+const FAILURES = [
+    {
+        pattern: /bind \[?([^\]\s]+)\]?:(\d+): (.+)/,
+        reason: (match) => `Could not bind ${match[1]}:${match[2]} — ${match[3].trim()}.`
+    },
+    {
+        pattern: /Warning: remote port forwarding failed for listen port (\d+)/,
+        reason: (match) => `The remote host refused to open port ${match[1]}. Its sshd may need GatewayPorts enabled to bind beyond loopback.`
+    },
+    {
+        pattern: /channel_setup_fwd_listener_tcpip: cannot listen to port: (\d+)/,
+        reason: (match) => `Could not listen on port ${match[1]}.`
+    },
+    { pattern: /Permission denied \(([^)]*)\)/, reason: (match) => `Authentication failed (${match[1]}).` },
+    { pattern: /(?:ssh: )?Could not resolve hostname ([^\s:]+)/, reason: (match) => `Could not resolve ${match[1]}.` },
+    { pattern: /Connection (?:refused|timed out|closed) by ([^\s]+)/, reason: (match) => `The host ${match[1]} refused the connection.` },
+    { pattern: /(ssh: connect to host [^\r\n]+)/, reason: (match) => `${match[1].trim()}.` },
+    { pattern: /Host key verification failed/, reason: () => 'Host key verification failed.' }
+];
+/**
+ * What the client's output so far says about the tunnel.
+ *
+ * Read from the whole buffer rather than the tail: `-v` is talkative, and the one
+ * line that matters is followed by many that do not. Failure is checked before
+ * success because ssh reports a partial success — one forward of several — while
+ * still exiting.
+ */
+export function readForwardOutcome(buffer, direction) {
+    for (const { pattern, reason } of FAILURES) {
+        const match = buffer.match(pattern);
+        if (match)
+            return { kind: 'failed', reason: reason(match) };
+    }
+    const success = direction === 'local'
+        ? /Local forwarding listening on \S+ port (\d+)/
+        : /remote forward success for: listen (\d+)/;
+    if (success.test(buffer))
+        return { kind: 'open' };
+    // Not proof of a tunnel, but it does mean the connection got that far — the
+    // service uses it to start the settle timer rather than waiting the full
+    // timeout on a host that never answered at all.
+    if (/Authentication succeeded|debug1: Entering interactive session/.test(buffer)) {
+        return { kind: 'authenticated' };
+    }
+    return null;
+}
+/** How a forward reads in the UI and in a log line. */
+export function describeForward(request) {
+    const destinationHost = request.destinationHost || DEFAULT_DESTINATION_HOST;
+    const listener = request.bind === 'all' ? '0.0.0.0' : 'localhost';
+    return request.direction === 'local'
+        ? `${listener}:${request.listenPort} → ${destinationHost}:${request.destinationPort} on ${request.target}`
+        : `${request.target}:${request.listenPort} → ${destinationHost}:${request.destinationPort} here`;
+}

package/dist/main/main/port-forward-service.js

@@ -0,0 +1,230 @@
+import { randomUUID } from 'node:crypto';
+import { createRequire } from 'node:module';
+import { homedir } from 'node:os';
+import { FORWARD_SETTLE_MS, buildForwardArgs, describeForward, readForwardOutcome } from './port-forward-protocol.js';
+import { detectPrompt } from './sftp-protocol.js';
+// node-pty is a native addon with no ESM entry point, and this file is compiled
+// as a module. Same shim as session-service.ts and sftp-service.ts.
+const require = createRequire(import.meta.url);
+/** A ceiling on live tunnels, so a stuck panel cannot spawn clients forever. */
+const MAX_FORWARDS = 16;
+/** Nothing at all from the client within this long means the host never answered. */
+const FIRST_BYTE_MS = 20000;
+/** Kept small: this is a debug log, not a terminal, and only the tail matters. */
+const BUFFER_CHARS = 8000;
+/** How the client's own line endings behave, as with the transfer side. */
+const TERMINATOR = '\n';
+/**
+ * The `ssh -N` processes behind shared ports.
+ *
+ * One process per tunnel. It cannot be otherwise: a forward cannot be added to
+ * the connection a terminal pane already holds without either typing `~C`
+ * escapes into the pty the user is typing in, or ControlMaster, which Windows
+ * OpenSSH does not have. One process each also makes closing exact — kill that
+ * process and that tunnel is gone, with nothing else disturbed.
+ *
+ * The pty is not for a remote tty; `-N` runs no remote command. It is so `ssh`
+ * has a terminal to ask for a password on, the same reason the transfer side
+ * uses one, which is why prompt handling here is `detectPrompt` unchanged.
+ */
+export class PortForwardService {
+    forwards = new Map();
+    spawnPty;
+    onEvent;
+    settleMs;
+    constructor(options = {}) {
+        this.spawnPty = options.spawnPty ?? ((file, args, ptyOptions) => require('node-pty').spawn(file, args, ptyOptions));
+        this.onEvent = options.onEvent ?? (() => undefined);
+        this.settleMs = options.settleMs ?? FORWARD_SETTLE_MS;
+    }
+    list() {
+        return [...this.forwards.values()].map((forward) => ({ ...forward.info }));
+    }
+    /**
+     * Open a tunnel, resolving once it is actually listening.
+     *
+     * A password or host-key question arrives as an event while this is still
+     * pending, and is answered with answerPrompt() — the same shape as the
+     * transfer panel, because it is the same client asking.
+     */
+    async open(request) {
+        // Built before anything is spawned, so an invalid request is a sentence
+        // rather than a process that dies a moment later.
+        const { file, args, spec } = buildForwardArgs(request);
+        const existing = this.findConflict(request);
+        if (existing) {
+            throw new Error(`Port ${request.listenPort} is already shared ${existing.direction === 'local' ? 'from' : 'to'} ${existing.target}.`);
+        }
+        if (this.forwards.size >= MAX_FORWARDS) {
+            throw new Error('Too many shared ports. Close one and try again.');
+        }
+        const id = request.id ?? `forward:${randomUUID()}`;
+        // Logged because which client got picked, and with which spec, is the first
+        // thing worth knowing when a tunnel does not work on someone else's machine.
+        console.log('[zerog] forward open', { file, args });
+        const info = { ...request, id, status: 'connecting' };
+        const pty = this.spawnPty(file, args, {
+            name: 'xterm-256color',
+            cols: 120,
+            rows: 30,
+            cwd: homedir(),
+            env: process.env
+        });
+        const forward = { info, pty, buffer: '', settle: null, settleTimer: undefined, firstByteTimer: undefined, closed: false };
+        this.forwards.set(id, forward);
+        pty.onData((data) => this.receive(forward, data));
+        pty.onExit(() => this.handleExit(forward));
+        this.emitStatus(forward);
+        return new Promise((resolve, reject) => {
+            forward.settle = { resolve, reject };
+            forward.firstByteTimer = setTimeout(() => {
+                this.fail(forward, `${describeForward(request)} did not answer.`);
+            }, FIRST_BYTE_MS);
+        });
+    }
+    answerPrompt(forwardId, answer) {
+        const forward = this.forwards.get(forwardId);
+        if (!forward)
+            throw new Error('That shared port is no longer open.');
+        if (/[\r\n]/.test(answer))
+            throw new Error('An answer must be a single line.');
+        lastQuestion.delete(forwardId);
+        forward.pty.write(`${answer}${TERMINATOR}`);
+    }
+    /**
+     * Close a tunnel.
+     *
+     * There is no graceful handshake to attempt: `ssh -N` is doing nothing but
+     * holding the forward open, so killing it is the clean way to let it go.
+     */
+    close(forwardId) {
+        const forward = this.forwards.get(forwardId);
+        if (!forward)
+            return;
+        this.destroy(forward, 'Closed.');
+    }
+    closeAll() {
+        for (const id of [...this.forwards.keys()])
+            this.close(id);
+    }
+    /**
+     * A tunnel that already binds what this request wants.
+     *
+     * Checked here rather than only in the renderer because a second listener on
+     * the same port cannot work, and spawning a client to find that out gives the
+     * user an ssh error instead of a sentence. A local forward's port is bound on
+     * this machine and a remote forward's on the far host, so the two only
+     * conflict with their own kind — and a remote one only per host.
+     */
+    findConflict(request) {
+        return this.list().find((candidate) => {
+            if (candidate.id === request.id)
+                return false;
+            if (candidate.listenPort !== request.listenPort)
+                return false;
+            if (candidate.direction !== request.direction)
+                return false;
+            return request.direction === 'local' || candidate.target === request.target;
+        });
+    }
+    receive(forward, data) {
+        if (forward.closed)
+            return;
+        clearTimeout(forward.firstByteTimer);
+        forward.firstByteTimer = undefined;
+        forward.buffer = (forward.buffer + data).slice(-BUFFER_CHARS);
+        const question = detectPrompt(forward.buffer);
+        if (question) {
+            // Only once per question: a rejected password is followed by the very same
+            // prompt text, and the user has to be given the field again.
+            if (lastQuestion.get(forward.info.id) !== question.text) {
+                lastQuestion.set(forward.info.id, question.text);
+                this.onEvent({ type: 'prompt', forwardId: forward.info.id, prompt: question });
+            }
+            return;
+        }
+        const outcome = readForwardOutcome(forward.buffer, forward.info.direction);
+        if (!outcome)
+            return;
+        if (outcome.kind === 'failed') {
+            this.fail(forward, outcome.reason);
+            return;
+        }
+        if (outcome.kind === 'open') {
+            this.succeed(forward);
+            return;
+        }
+        // Authenticated but not yet listening. Give the client a moment to say it
+        // started, and take silence as success rather than failing a tunnel that an
+        // ssh build words differently from the one this was written against.
+        if (!forward.settleTimer) {
+            forward.settleTimer = setTimeout(() => {
+                if (!forward.closed && forward.info.status === 'connecting')
+                    this.succeed(forward);
+            }, this.settleMs);
+        }
+    }
+    succeed(forward) {
+        clearTimeout(forward.settleTimer);
+        forward.settleTimer = undefined;
+        forward.info.status = 'open';
+        delete forward.info.message;
+        this.emitStatus(forward);
+        const settle = forward.settle;
+        forward.settle = null;
+        settle?.resolve({ ...forward.info });
+    }
+    fail(forward, reason) {
+        const settle = forward.settle;
+        forward.settle = null;
+        forward.info.status = 'error';
+        forward.info.message = reason;
+        this.emitStatus(forward);
+        this.destroy(forward, reason, { keepStatus: true });
+        if (settle)
+            settle.reject(new Error(reason));
+    }
+    /**
+     * The client exited on its own.
+     *
+     * With ExitOnForwardFailure this is how a forward that could not bind reports
+     * itself, so the buffer is worth one more read before falling back to a
+     * generic message.
+     */
+    handleExit(forward) {
+        if (forward.closed)
+            return;
+        const outcome = readForwardOutcome(forward.buffer, forward.info.direction);
+        const reason = outcome?.kind === 'failed'
+            ? outcome.reason
+            : forward.info.status === 'open'
+                ? 'The connection closed.'
+                : `Could not share port ${forward.info.listenPort}.`;
+        this.fail(forward, reason);
+    }
+    destroy(forward, message, options = {}) {
+        if (forward.closed)
+            return;
+        forward.closed = true;
+        clearTimeout(forward.settleTimer);
+        clearTimeout(forward.firstByteTimer);
+        try {
+            forward.pty.kill();
+        }
+        catch {
+            /* already gone */
+        }
+        this.forwards.delete(forward.info.id);
+        lastQuestion.delete(forward.info.id);
+        if (!options.keepStatus) {
+            forward.info.status = 'idle';
+            this.emitStatus(forward);
+        }
+        this.onEvent({ type: 'closed', forwardId: forward.info.id, message });
+    }
+    emitStatus(forward) {
+        this.onEvent({ type: 'status', forward: { ...forward.info } });
+    }
+}
+/** The last question each tunnel asked, so it is only surfaced once. */
+const lastQuestion = new Map();

package/dist/main/main/port-forward-store.js

@@ -0,0 +1,133 @@
+import { mkdir, readFile, rename, writeFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { randomUUID } from 'node:crypto';
+const SCHEMA_VERSION = 1;
+const MAX_FORWARDS = 64;
+/**
+ * Main-process-only, best-effort memory of which ports were shared.
+ *
+ * Stores where a tunnel went and how wide it was bound — never a credential, a
+ * cwd, or command arguments — the same guarantee SessionHistoryStore and
+ * WorkspaceStore make, and for the same reason: this is plain JSON in the user's
+ * profile.
+ *
+ * Nothing here reopens a tunnel. Restored forwards come back as rows waiting to
+ * be clicked, so launching the app never dials out to a host on its own.
+ */
+export class PortForwardStore {
+    filePath;
+    file = { version: SCHEMA_VERSION, forwards: [] };
+    loaded = false;
+    writeQueue = Promise.resolve();
+    constructor(options) {
+        this.filePath = options.filePath;
+    }
+    async load() {
+        await this.ensureLoaded();
+        return normalizeFile(this.file) ?? { version: SCHEMA_VERSION, forwards: [] };
+    }
+    async save(input) {
+        await this.ensureLoaded();
+        // Validated on the way in as well as out: the renderer is the only caller,
+        // but this is an IPC boundary, and a stored bad value would come back on
+        // every launch from then on.
+        const normalized = normalizeFile(input);
+        if (!normalized)
+            throw new Error('Invalid shared port list.');
+        this.file = normalized;
+        await this.persist();
+        return normalized;
+    }
+    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, forwards: [] };
+        }
+    }
+    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), `.port-forwards.tmp-${process.pid}-${randomUUID()}`);
+                await writeFile(temp, JSON.stringify(snapshot, null, 2), { encoding: 'utf8', mode: 0o600 });
+                await rename(temp, this.filePath);
+            }
+            catch {
+                // Remembering a port must never affect terminal operation.
+            }
+        });
+        await this.writeQueue;
+    }
+}
+/** Strip control characters and cap length; the file is user-editable. */
+function safeText(value, limit = 256) {
+    return value.replace(/[\u0000-\u001f\u007f]/g, '').slice(0, limit);
+}
+function port(value) {
+    if (typeof value !== 'number' || !Number.isInteger(value) || value < 1 || value > 65535)
+        return undefined;
+    return value;
+}
+function normalizeForward(value) {
+    if (!value || typeof value !== 'object')
+        return undefined;
+    const item = value;
+    if (typeof item.id !== 'string' || typeof item.target !== 'string')
+        return undefined;
+    if (item.direction !== 'local' && item.direction !== 'remote')
+        return undefined;
+    // A missing or unrecognised bind reads as loopback, never as the wide one: a
+    // hand-edited or truncated file must not be able to widen a forward silently.
+    const bind = item.bind === 'all' ? 'all' : 'loopback';
+    const listenPort = port(item.listenPort);
+    const destinationPort = port(item.destinationPort);
+    const id = safeText(item.id, 64);
+    const target = safeText(item.target, 256);
+    if (!id || !target || listenPort === undefined || destinationPort === undefined)
+        return undefined;
+    const forward = { id, target, direction: item.direction, listenPort, destinationPort, bind };
+    // Left off entirely when absent, so the protocol's own default applies rather
+    // than an empty string reaching the forward spec.
+    const destinationHost = typeof item.destinationHost === 'string' ? safeText(item.destinationHost, 253) : '';
+    if (destinationHost)
+        forward.destinationHost = destinationHost;
+    return forward;
+}
+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.forwards))
+        return undefined;
+    const forwards = [];
+    const seen = new Set();
+    for (const raw of item.forwards) {
+        const forward = normalizeForward(raw);
+        if (!forward || seen.has(forward.id))
+            continue;
+        seen.add(forward.id);
+        forwards.push(forward);
+        if (forwards.length >= MAX_FORWARDS)
+            break;
+    }
+    return { version: SCHEMA_VERSION, forwards };
+}
+/** What is worth remembering about a live tunnel: everything but how it is doing. */
+export function forgetStatus(forward) {
+    const { status, message, ...rest } = forward;
+    return rest;
+}
+export function defaultPortForwardPath(userDataPath) {
+    return join(userDataPath, 'port-forwards.json');
+}

package/dist/main/main/preload.cjs

@@ -4,6 +4,23 @@ const api = {
   listSessions: () => ipcRenderer.invoke('sessions:list'),
   listHistory: () => ipcRenderer.invoke('sessions:history'),
   removeHistory: (entryId) => ipcRenderer.invoke('sessions:historyRemove', entryId),
+  listCommandHistory: () => ipcRenderer.invoke('commands:list'),
+  recordCommand: (record) => ipcRenderer.invoke('commands:record', record),
+  pickCommand: (id) => ipcRenderer.invoke('commands:pick', id),
+  clearCommandHistory: () => ipcRenderer.invoke('commands:clear'),
+  listForwards: () => ipcRenderer.invoke('forwards:list'),
+  openForward: (request) => ipcRenderer.invoke('forwards:open', request),
+  closeForward: (id) => ipcRenderer.invoke('forwards:close', id),
+  answerForwardPrompt: (id, answer) => ipcRenderer.invoke('forwards:answerPrompt', id, answer),
+  loadForwards: () => ipcRenderer.invoke('forwards:load'),
+  saveForwards: (file) => ipcRenderer.invoke('forwards:save', file),
+  onForwardEvent: (callback) => {
+    const listener = (_event, payload) => callback(payload);
+    ipcRenderer.on('forwards:event', listener);
+    return () => ipcRenderer.removeListener('forwards:event', listener);
+  },
+  loadWorkspaces: () => ipcRenderer.invoke('workspaces:load'),
+  saveWorkspaces: (file) => ipcRenderer.invoke('workspaces:save', file),
   listBackends: () => ipcRenderer.invoke('sessions:backends'),
   listWslDistributions: () => ipcRenderer.invoke('sessions:wslDistributions'),
   createLocalSession: (request) => ipcRenderer.invoke('sessions:createLocal', request),
@@ -27,9 +44,17 @@ const api = {
     ipcRenderer.on('terminal:status', listener);
     return () => ipcRenderer.removeListener('terminal:status', listener);
   },
-  requestAiCommand: () => ipcRenderer.invoke('ai:suggest'),
+  requestAiCommand: (config, request) => ipcRenderer.invoke('ai:suggest', config, request),
+  listAiModels: (baseUrl) => ipcRenderer.invoke('ai:models', baseUrl),
+  testAiEndpoint: (config) => ipcRenderer.invoke('ai:test', config),
+  cancelAiRequest: () => ipcRenderer.invoke('ai:cancel'),
+  aiApiKeyStatus: () => ipcRenderer.invoke('aiKey:status'),
+  saveAiApiKey: (key) => ipcRenderer.invoke('aiKey:save', key),
+  clearAiApiKey: () => ipcRenderer.invoke('aiKey:clear'),
   listLocalDirectory: (path) => ipcRenderer.invoke('fs:listLocal', path),
+  appVersion: () => ipcRenderer.invoke('app:version'),
   localHome: () => ipcRenderer.invoke('fs:localHome'),
+  wslHome: (distribution) => ipcRenderer.invoke('fs:wslHome', distribution),
   createLocalDirectory: (path) => ipcRenderer.invoke('fs:mkdirLocal', path),
   renameLocalEntry: (from, to) => ipcRenderer.invoke('fs:renameLocal', from, to),
   removeLocalEntry: (path, kind) => ipcRenderer.invoke('fs:removeLocal', path, kind),
@@ -47,6 +72,10 @@ const api = {
     ipcRenderer.on('sftp:event', listener);
     return () => ipcRenderer.removeListener('sftp:event', listener);
   },
+  speechApiKeyStatus: () => ipcRenderer.invoke('speechKey:status'),
+  saveSpeechApiKey: (key) => ipcRenderer.invoke('speechKey:save', key),
+  clearSpeechApiKey: () => ipcRenderer.invoke('speechKey:clear'),
+  readSpeechApiKey: () => ipcRenderer.invoke('speechKey:read'),
   openExternal: (url) => ipcRenderer.invoke('links:openExternal', url),
   onLinkRefused: (callback) => {
     const listener = (_event, reason) => callback(reason);