@steerable/agent-cli 0.6.60 → 0.6.62

package/dist/tui/children.d.ts

@@ -0,0 +1,17 @@
+export interface ChildRow {
+    id: string;
+    task: string;
+    profile: string;
+    status: 'running' | 'completed' | 'failed' | 'cancelled' | 'interrupted';
+    depth: number;
+}
+export interface ChildEvent {
+    kind?: unknown;
+    childId?: unknown;
+    task?: unknown;
+    profile?: unknown;
+    depth?: unknown;
+}
+/** Fold one `orchestration_child` lifecycle event into the live sub-agent list. */
+export declare function applyChildEvent(children: readonly ChildRow[], event: ChildEvent): ChildRow[];
+export declare function childLines(children: readonly ChildRow[]): string[];

package/dist/tui/children.js

@@ -0,0 +1,74 @@
+/** Fold one `orchestration_child` lifecycle event into the live sub-agent list. */
+export function applyChildEvent(children, event) {
+    const kind = typeof event.kind === 'string' ? event.kind : '';
+    const id = typeof event.childId === 'string' ? event.childId : '';
+    if (!kind || !id)
+        return [...children];
+    const next = children.map((child) => ({ ...child }));
+    const index = next.findIndex((child) => child.id === id);
+    if (kind === 'child_spawned') {
+        if (index >= 0)
+            return next;
+        next.push({
+            id,
+            task: typeof event.task === 'string' ? event.task : '',
+            profile: typeof event.profile === 'string' ? event.profile : '',
+            depth: typeof event.depth === 'number' ? Math.max(0, event.depth) : 0,
+            status: 'running',
+        });
+        return next;
+    }
+    const current = next[index];
+    if (!current)
+        return next;
+    next[index] = { ...current, status: childStatus(kind, current.status) };
+    return next;
+}
+export function childLines(children) {
+    if (children.length === 0)
+        return [];
+    const done = children.filter((child) => child.status === 'completed').length;
+    const lines = [`子任务 ${done}/${children.length}`];
+    for (const child of children) {
+        const name = child.profile || '子任务';
+        const task = child.task ? `  ${child.task}` : '';
+        const indent = '  '.repeat(Math.min(child.depth, 6));
+        lines.push(`${indent}${statusMark(child.status)} ${name}${task}  ${statusLabel(child.status)}`);
+    }
+    return lines;
+}
+function childStatus(kind, current) {
+    if (kind === 'child_completed')
+        return 'completed';
+    if (kind === 'child_failed')
+        return 'failed';
+    if (kind === 'child_cancelled')
+        return 'cancelled';
+    if (kind === 'child_interrupted')
+        return 'interrupted';
+    if (kind === 'child_resumed')
+        return 'running';
+    return current;
+}
+function statusMark(status) {
+    if (status === 'completed')
+        return '✓';
+    if (status === 'failed')
+        return '✗';
+    if (status === 'cancelled')
+        return '·';
+    if (status === 'interrupted')
+        return '‖';
+    return '▸';
+}
+function statusLabel(status) {
+    if (status === 'completed')
+        return '完成';
+    if (status === 'failed')
+        return '失败';
+    if (status === 'cancelled')
+        return '已取消';
+    if (status === 'interrupted')
+        return '已暂停';
+    return '进行中';
+}

package/dist/tui/clipboard.d.ts

@@ -0,0 +1,14 @@
+export interface ClipboardRead {
+    image?: Uint8Array | null;
+    text?: string | null;
+}
+/** File extension for a clipboard image, or null when the bytes are not a supported picture. */
+export declare function imageExtension(bytes: Uint8Array): 'png' | 'jpg' | 'gif' | 'webp' | null;
+/** Write clipboard image bytes to a temp file the attachment path can send. */
+export declare function saveClipboardImage(bytes: Uint8Array): Promise<{
+    name: string;
+    path: string;
+} | null>;
+/** Image first, then text. An empty clipboard returns an empty result. */
+export declare function writeSystemClipboard(text: string): Promise<void>;
+export declare function readSystemClipboard(): Promise<ClipboardRead>;

package/dist/tui/clipboard.js

@@ -0,0 +1,58 @@
+import { randomUUID } from 'node:crypto';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { getNativeClipboard } from '@earendil-works/pi-tui';
+/** File extension for a clipboard image, or null when the bytes are not a supported picture. */
+export function imageExtension(bytes) {
+    if (bytes.length >= 8 && bytes[0] === 0x89 && bytes[1] === 0x50 && bytes[2] === 0x4e && bytes[3] === 0x47)
+        return 'png';
+    if (bytes.length >= 3 && bytes[0] === 0xff && bytes[1] === 0xd8 && bytes[2] === 0xff)
+        return 'jpg';
+    if (bytes.length >= 6 && bytes[0] === 0x47 && bytes[1] === 0x49 && bytes[2] === 0x46)
+        return 'gif';
+    if (bytes.length >= 12
+        && bytes[0] === 0x52 && bytes[1] === 0x49 && bytes[2] === 0x46 && bytes[3] === 0x46
+        && bytes[8] === 0x57 && bytes[9] === 0x45 && bytes[10] === 0x42 && bytes[11] === 0x50)
+        return 'webp';
+    return null;
+}
+/** Write clipboard image bytes to a temp file the attachment path can send. */
+export async function saveClipboardImage(bytes) {
+    const ext = imageExtension(bytes);
+    if (!ext)
+        return null;
+    const name = `clipboard-${randomUUID().slice(0, 8)}.${ext}`;
+    const file = path.join(os.tmpdir(), `steerable-${name}`);
+    await fs.writeFile(file, bytes);
+    return { name, path: file };
+}
+/** Image first, then text. An empty clipboard returns an empty result. */
+export async function writeSystemClipboard(text) {
+    const clipboard = getNativeClipboard();
+    if (!clipboard?.setText)
+        throw new Error('clipboard unavailable');
+    await clipboard.setText(text);
+}
+export async function readSystemClipboard() {
+    const clipboard = getNativeClipboard();
+    if (!clipboard)
+        return {};
+    try {
+        const image = await clipboard.getImage();
+        if (image && image.length > 0)
+            return { image };
+    }
+    catch (error) {
+        void error;
+    }
+    try {
+        const text = await clipboard.getText();
+        if (text)
+            return { text };
+    }
+    catch (error) {
+        void error;
+    }
+    return {};
+}

package/dist/tui/commands.d.ts

@@ -0,0 +1,9 @@
+import type { FilePick } from './files.js';
+export interface SlashToken {
+    start: number;
+    query: string;
+}
+/** A `/command` at the start of the draft, touching the cursor. */
+export declare function slashAt(text: string, cursor: number): SlashToken | null;
+/** Commands already implemented by the composer, filtered by the text after `/`. */
+export declare function completeSlash(query: string): FilePick[];

package/dist/tui/commands.js

@@ -0,0 +1,41 @@
+const COMMANDS = [
+    { name: 'new', hint: '新会话' },
+    { name: 'model', hint: '查看或切换模型' },
+    { name: 'attach', hint: '附加文件' },
+    { name: 'clear', hint: '清屏' },
+    { name: 'help', hint: '帮助' },
+    { name: 'status', hint: '用量' },
+    { name: 'skills', hint: '技能' },
+    { name: 'mcp', hint: 'MCP' },
+    { name: 'export', hint: '导出会话' },
+    { name: 'compact', hint: '压缩上下文' },
+    { name: 'plan', hint: '计划模式' },
+    { name: 'tasks', hint: '后台任务' },
+    { name: 'fork', hint: '分叉' },
+    { name: 'rewind', hint: '回退' },
+    { name: 'permissions', hint: '会话权限' },
+    { name: 'copy', hint: '复制回答' },
+    { name: 'editor', hint: '外部编辑器' },
+];
+/** A `/command` at the start of the draft, touching the cursor. */
+export function slashAt(text, cursor) {
+    const at = Math.max(0, Math.min(cursor, text.length));
+    const head = text.slice(0, at);
+    if (head.includes('\n'))
+        return null;
+    const match = /^\/([^\s]*)$/.exec(head);
+    if (!match)
+        return null;
+    return { start: 0, query: match[1] ?? '' };
+}
+/** Commands already implemented by the composer, filtered by the text after `/`. */
+export function completeSlash(query) {
+    const needle = query.toLowerCase();
+    return COMMANDS
+        .filter((command) => command.name.startsWith(needle))
+        .map((command) => ({
+        label: `/${command.name} ${command.hint}`,
+        insert: `/${command.name} `,
+        directory: false,
+    }));
+}

package/dist/tui/editor.d.ts

@@ -0,0 +1,18 @@
+export interface DraftBuffer {
+    text: string;
+    cursor: number;
+}
+export declare function createDraft(): DraftBuffer;
+export declare function clearDraft(draft: DraftBuffer): void;
+export declare function insertText(draft: DraftBuffer, text: string): void;
+/** Place the caret inside `text`. `head` is the grapheme under an insert cursor. */
+export declare function splitAtCursor(text: string, cursor: number): {
+    before: string;
+    head: string;
+    after: string;
+};
+/**
+ * Apply one composer key.
+ * `submit` leaves the buffer unchanged so the caller can send it.
+ */
+export declare function editDraft(draft: DraftBuffer, data: string): 'submit' | 'edited' | 'ignored';

package/dist/tui/editor.js

@@ -0,0 +1,201 @@
+import { decodeKittyPrintable, getKeybindings } from '@earendil-works/pi-tui';
+const segmenter = new Intl.Segmenter(undefined, { granularity: 'grapheme' });
+export function createDraft() {
+    return { text: '', cursor: 0 };
+}
+export function clearDraft(draft) {
+    draft.text = '';
+    draft.cursor = 0;
+}
+export function insertText(draft, text) {
+    const at = clamp(draft.cursor, draft.text.length);
+    draft.text = draft.text.slice(0, at) + text + draft.text.slice(at);
+    draft.cursor = at + text.length;
+}
+/** Place the caret inside `text`. `head` is the grapheme under an insert cursor. */
+export function splitAtCursor(text, cursor) {
+    const at = clamp(cursor, text.length);
+    const rest = text.slice(at);
+    const head = graphemesOf(rest)[0]?.text ?? '';
+    return { before: text.slice(0, at), head, after: rest.slice(head.length) };
+}
+/**
+ * Apply one composer key.
+ * `submit` leaves the buffer unchanged so the caller can send it.
+ */
+export function editDraft(draft, data) {
+    const keys = getKeybindings();
+    if (keys.matches(data, 'tui.input.newLine') || isLegacyNewline(data)) {
+        insertText(draft, '\n');
+        return 'edited';
+    }
+    if (keys.matches(data, 'tui.input.submit'))
+        return 'submit';
+    if (keys.matches(data, 'tui.editor.deleteCharBackward')) {
+        deleteSpan(draft, previousGrapheme(draft.text, draft.cursor), draft.cursor);
+        return 'edited';
+    }
+    if (keys.matches(data, 'tui.editor.deleteCharForward')) {
+        deleteSpan(draft, draft.cursor, nextGrapheme(draft.text, draft.cursor));
+        return 'edited';
+    }
+    if (keys.matches(data, 'tui.editor.deleteWordBackward')) {
+        deleteSpan(draft, wordBoundary(draft.text, draft.cursor, -1), draft.cursor);
+        return 'edited';
+    }
+    if (keys.matches(data, 'tui.editor.deleteWordForward')) {
+        deleteSpan(draft, draft.cursor, wordBoundary(draft.text, draft.cursor, 1));
+        return 'edited';
+    }
+    if (keys.matches(data, 'tui.editor.deleteToLineStart')) {
+        deleteSpan(draft, lineStart(draft.text, draft.cursor), draft.cursor);
+        return 'edited';
+    }
+    if (keys.matches(data, 'tui.editor.deleteToLineEnd')) {
+        deleteSpan(draft, draft.cursor, lineEnd(draft.text, draft.cursor));
+        return 'edited';
+    }
+    if (keys.matches(data, 'tui.editor.cursorLeft')) {
+        draft.cursor = previousGrapheme(draft.text, draft.cursor);
+        return 'edited';
+    }
+    if (keys.matches(data, 'tui.editor.cursorRight')) {
+        draft.cursor = nextGrapheme(draft.text, draft.cursor);
+        return 'edited';
+    }
+    if (keys.matches(data, 'tui.editor.cursorLineStart')) {
+        draft.cursor = lineStart(draft.text, draft.cursor);
+        return 'edited';
+    }
+    if (keys.matches(data, 'tui.editor.cursorLineEnd')) {
+        draft.cursor = lineEnd(draft.text, draft.cursor);
+        return 'edited';
+    }
+    if (keys.matches(data, 'tui.editor.cursorWordLeft')) {
+        draft.cursor = wordBoundary(draft.text, draft.cursor, -1);
+        return 'edited';
+    }
+    if (keys.matches(data, 'tui.editor.cursorWordRight')) {
+        draft.cursor = wordBoundary(draft.text, draft.cursor, 1);
+        return 'edited';
+    }
+    if (keys.matches(data, 'tui.editor.cursorUp')) {
+        draft.cursor = moveLine(draft.text, draft.cursor, -1);
+        return 'edited';
+    }
+    if (keys.matches(data, 'tui.editor.cursorDown')) {
+        draft.cursor = moveLine(draft.text, draft.cursor, 1);
+        return 'edited';
+    }
+    const kitty = decodeKittyPrintable(data);
+    if (kitty) {
+        insertText(draft, kitty);
+        return 'edited';
+    }
+    if (isPrintable(data)) {
+        insertText(draft, data);
+        return 'edited';
+    }
+    return 'ignored';
+}
+function deleteSpan(draft, from, to) {
+    const start = clamp(Math.min(from, to), draft.text.length);
+    const end = clamp(Math.max(from, to), draft.text.length);
+    if (start === end)
+        return;
+    draft.text = draft.text.slice(0, start) + draft.text.slice(end);
+    draft.cursor = start;
+}
+function previousGrapheme(text, cursor) {
+    const at = clamp(cursor, text.length);
+    const prior = graphemesOf(text).filter((part) => part.end <= at);
+    return prior[prior.length - 1]?.start ?? 0;
+}
+function nextGrapheme(text, cursor) {
+    const at = clamp(cursor, text.length);
+    return graphemesOf(text).find((part) => part.start >= at)?.end ?? text.length;
+}
+function lineStart(text, cursor) {
+    const at = clamp(cursor, text.length);
+    if (at === 0)
+        return 0;
+    const index = text.lastIndexOf('\n', at - 1);
+    return index < 0 ? 0 : index + 1;
+}
+function lineEnd(text, cursor) {
+    const at = clamp(cursor, text.length);
+    const index = text.indexOf('\n', at);
+    return index < 0 ? text.length : index;
+}
+function wordBoundary(text, cursor, direction) {
+    const parts = graphemesOf(text);
+    const at = clamp(cursor, text.length);
+    if (direction < 0) {
+        let index = -1;
+        for (let part = 0; part < parts.length; part += 1) {
+            if ((parts[part]?.end ?? 0) <= at)
+                index = part;
+        }
+        while (index >= 0 && isSpace(parts[index]?.text ?? ''))
+            index -= 1;
+        while (index >= 0 && !isSpace(parts[index]?.text ?? ''))
+            index -= 1;
+        return parts[index + 1]?.start ?? 0;
+    }
+    let index = parts.findIndex((part) => part.start >= at);
+    if (index < 0)
+        return text.length;
+    while (index < parts.length && isSpace(parts[index]?.text ?? ''))
+        index += 1;
+    while (index < parts.length && !isSpace(parts[index]?.text ?? ''))
+        index += 1;
+    return parts[index - 1]?.end ?? text.length;
+}
+function moveLine(text, cursor, direction) {
+    const at = clamp(cursor, text.length);
+    const start = lineStart(text, at);
+    const column = graphemesOf(text.slice(start, at)).length;
+    if (direction < 0) {
+        if (start === 0)
+            return at;
+        const previousEnd = start - 1;
+        return columnOnLine(text, lineStart(text, previousEnd), previousEnd, column);
+    }
+    const end = lineEnd(text, at);
+    if (end >= text.length)
+        return at;
+    const nextStart = end + 1;
+    return columnOnLine(text, nextStart, lineEnd(text, nextStart), column);
+}
+function columnOnLine(text, start, end, column) {
+    const parts = graphemesOf(text.slice(start, end));
+    if (column >= parts.length)
+        return end;
+    return start + (parts[column]?.start ?? 0);
+}
+function graphemesOf(text) {
+    return [...segmenter.segment(text)].map((part) => ({
+        start: part.index,
+        end: part.index + part.segment.length,
+        text: part.segment,
+    }));
+}
+function isSpace(text) {
+    return text.length > 0 && /^\s+$/u.test(text);
+}
+function isLegacyNewline(data) {
+    if (data === '\x1b\r' || data === '\x1b[13;2~')
+        return true;
+    return data.length > 1 && data.includes('\x1b') && data.includes('\r');
+}
+function isPrintable(data) {
+    if (data.length === 0)
+        return false;
+    return [...data].every((char) => {
+        const code = char.codePointAt(0) ?? 0;
+        return code >= 32 && code !== 0x7f && (code < 0x80 || code > 0x9f);
+    });
+}
+function clamp(cursor, length) {
+    return Math.max(0, Math.min(cursor, length));
+}

package/dist/tui/export-chat.d.ts

@@ -0,0 +1,4 @@
+export declare function markdownChat(title: string, messages: readonly {
+    role?: string;
+    content?: string;
+}[]): string;

package/dist/tui/export-chat.js

@@ -0,0 +1,7 @@
+export function markdownChat(title, messages) {
+    const parts = [`# ${title}`, ''];
+    for (const message of messages) {
+        parts.push(`## ${message.role ?? ''}`, '', message.content ?? '', '');
+    }
+    return `${parts.join('\n').replace(/\n$/, '')}\n`;
+}

package/dist/tui/files.d.ts

@@ -0,0 +1,23 @@
+export interface MentionToken {
+    start: number;
+    query: string;
+}
+export interface FilePick {
+    label: string;
+    insert: string;
+    directory: boolean;
+}
+export interface SavedFile {
+    name: string;
+    path: string;
+    error?: string;
+}
+/** The `@query` touching the cursor, if the `@` starts a token. */
+export declare function mentionAt(text: string, cursor: number): MentionToken | null;
+/** Files and directories under `root` whose relative path matches `@query`. */
+export declare function completeFiles(root: string, query: string, limit?: number): Promise<FilePick[]>;
+export declare function isImagePath(filePath: string): boolean;
+/** Append stored paths the way the web composer does, so the agent can read them back. */
+export declare function attachmentMessage(text: string, files: Array<{
+    path: string;
+}>): string;

package/dist/tui/files.js

@@ -0,0 +1,63 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+const IMAGE_EXTENSIONS = new Set(['.png', '.jpg', '.jpeg', '.gif', '.webp', '.bmp']);
+/** The `@query` touching the cursor, if the `@` starts a token. */
+export function mentionAt(text, cursor) {
+    const at = Math.max(0, Math.min(cursor, text.length));
+    const match = /(^|\s)@([^\s@]*)$/.exec(text.slice(0, at));
+    if (!match)
+        return null;
+    const query = match[2] ?? '';
+    return { start: at - query.length - 1, query };
+}
+/** Files and directories under `root` whose relative path matches `@query`. */
+export async function completeFiles(root, query, limit = 8) {
+    const normalized = query.replaceAll('\\', '/');
+    const slash = normalized.lastIndexOf('/');
+    const dirPart = slash >= 0 ? normalized.slice(0, slash) : '';
+    const prefix = slash >= 0 ? normalized.slice(slash + 1) : normalized;
+    let names;
+    try {
+        names = await fs.readdir(path.resolve(root, dirPart));
+    }
+    catch {
+        return [];
+    }
+    const visible = names
+        .filter((name) => (prefix.startsWith('.') ? true : !name.startsWith('.')))
+        .filter((name) => name.startsWith(prefix))
+        .sort((left, right) => left.localeCompare(right))
+        .slice(0, 40);
+    const picks = [];
+    for (const name of visible) {
+        const full = path.join(path.resolve(root, dirPart), name);
+        let directory = false;
+        try {
+            directory = (await fs.stat(full)).isDirectory();
+        }
+        catch {
+            continue;
+        }
+        const relative = path.relative(root, full).split(path.sep).join('/');
+        const shown = directory ? `${relative}/` : relative;
+        picks.push({
+            label: shown,
+            insert: `@${shown}${directory ? '' : ' '}`,
+            directory,
+        });
+    }
+    picks.sort((left, right) => Number(right.directory) - Number(left.directory) || left.label.localeCompare(right.label));
+    return picks.slice(0, limit);
+}
+export function isImagePath(filePath) {
+    const dot = filePath.lastIndexOf('.');
+    return dot >= 0 && IMAGE_EXTENSIONS.has(filePath.slice(dot).toLowerCase());
+}
+/** Append stored paths the way the web composer does, so the agent can read them back. */
+export function attachmentMessage(text, files) {
+    if (files.length === 0)
+        return text;
+    const refs = files.map((file) => `- \`${file.path}\``).join('\n');
+    const block = `相关文件：\n${refs}`;
+    return text ? `${text}\n\n---\n${block}` : block;
+}

package/dist/tui/keys.d.ts

@@ -10,6 +10,11 @@ declare module '@earendil-works/pi-tui' {
         'agent.approval.denySession': true;
         'agent.approval.denyAlways': true;
         'agent.approval.abort': true;
+        'agent.tool.toggle': true;
+        'agent.clipboard.paste': true;
+        'agent.queue.pull': true;
+        'agent.copy.reply': true;
+        'agent.editor': true;
     }
 }
 export declare const AGENT_KEYBINDINGS: {
@@ -49,7 +54,28 @@ export declare const AGENT_KEYBINDINGS: {
         readonly defaultKeys: "escape";
         readonly description: "Abort the turn";
     };
+    readonly 'agent.tool.toggle': {
+        readonly defaultKeys: "ctrl+o";
+        readonly description: "Expand the latest finished tool";
+    };
+    readonly 'agent.clipboard.paste': {
+        readonly defaultKeys: "ctrl+v" | "alt+v";
+        readonly description: "Paste an image or text from the clipboard";
+    };
+    readonly 'agent.queue.pull': {
+        readonly defaultKeys: "alt+up";
+        readonly description: "Pull the latest queued line back into the composer";
+    };
+    readonly 'agent.copy.reply': {
+        readonly defaultKeys: "alt+c";
+        readonly description: "Copy the latest assistant reply";
+    };
+    readonly 'agent.editor': {
+        readonly defaultKeys: "alt+e";
+        readonly description: "Edit the draft in an external editor";
+    };
 };
 export declare function installAgentKeybindings(user?: KeybindingsConfig): void;
 export declare function ensureAgentKeybindings(): void;
 export declare function keyLabel(id: Keybinding): string;
+export declare function formatKey(key: string, platform?: NodeJS.Platform): string;

package/dist/tui/keys.js

@@ -9,6 +9,14 @@ export const AGENT_KEYBINDINGS = {
     'agent.approval.denySession': { defaultKeys: 'shift+n', description: 'Deny this tool for the chat' },
     'agent.approval.denyAlways': { defaultKeys: 'shift+a', description: 'Always deny this tool' },
     'agent.approval.abort': { defaultKeys: 'escape', description: 'Abort the turn' },
+    'agent.tool.toggle': { defaultKeys: 'ctrl+o', description: 'Expand the latest finished tool' },
+    'agent.clipboard.paste': {
+        defaultKeys: process.platform === 'win32' ? 'alt+v' : 'ctrl+v',
+        description: 'Paste an image or text from the clipboard',
+    },
+    'agent.queue.pull': { defaultKeys: 'alt+up', description: 'Pull the latest queued line back into the composer' },
+    'agent.copy.reply': { defaultKeys: 'alt+c', description: 'Copy the latest assistant reply' },
+    'agent.editor': { defaultKeys: 'alt+e', description: 'Edit the draft in an external editor' },
 };
 const DEFINITIONS = { ...TUI_KEYBINDINGS, ...AGENT_KEYBINDINGS };
 export function installAgentKeybindings(user = {}) {
@@ -23,18 +31,52 @@ export function keyLabel(id) {
     const key = getKeybindings().getKeys(id)[0] ?? '';
     return formatKey(key);
 }
-function formatKey(key) {
-    if (key === 'escape')
-        return 'Esc';
+const MAC_NAME = {
+    ctrl: 'Control',
+    control: 'Control',
+    shift: 'Shift',
+    alt: 'Option',
+    opt: 'Option',
+    option: 'Option',
+    meta: 'Command',
+    cmd: 'Command',
+    command: 'Command',
+    super: 'Command',
+    enter: 'Return',
+    return: 'Return',
+    escape: 'Esc',
+    esc: 'Esc',
+    tab: 'Tab',
+    backspace: 'Delete',
+    delete: 'Forward Delete',
+    space: 'Space',
+};
+export function formatKey(key, platform = process.platform) {
     if (/^shift\+[a-z]$/.test(key))
         return key.slice('shift+'.length).toUpperCase();
+    if (platform === 'darwin') {
+        const parts = key.split('+');
+        return parts.map((part, index) => macName(part, parts.length > 1 && index === parts.length - 1)).join('+');
+    }
+    if (key === 'escape')
+        return 'Esc';
+    if (key === 'enter')
+        return 'Enter';
     if (!key.includes('+'))
         return key;
-    return key.split('+').map((part) => {
-        if (part === 'ctrl')
-            return 'Ctrl';
-        if (part.length === 1)
-            return part.toUpperCase();
-        return part[0].toUpperCase() + part.slice(1);
-    }).join('+');
+    return key.split('+').map((part) => wordPart(part)).join('+');
+}
+function macName(part, chordKey) {
+    if (MAC_NAME[part])
+        return MAC_NAME[part];
+    if (part.length === 1)
+        return chordKey ? part.toUpperCase() : part;
+    return part[0].toUpperCase() + part.slice(1);
+}
+function wordPart(part) {
+    if (part === 'ctrl')
+        return 'Ctrl';
+    if (part.length === 1)
+        return part.toUpperCase();
+    return part[0].toUpperCase() + part.slice(1);
 }