@forgeax/interface 0.4.1

package/dist/package/node/core/contextual-keybindings.js

@@ -0,0 +1,198 @@
+export const APPLICATION_KEYBINDING_SCOPE = 'application';
+function normalizeKey(key) {
+    if (!key)
+        return '';
+    if (key === ' ')
+        return 'Space';
+    if (key.length === 1)
+        return key.toUpperCase();
+    const aliases = {
+        Esc: 'Escape',
+        Del: 'Delete',
+        Left: 'ArrowLeft',
+        Right: 'ArrowRight',
+        Up: 'ArrowUp',
+        Down: 'ArrowDown',
+    };
+    return aliases[key] ?? key;
+}
+/** Some browsers omit `event.key` after autocomplete/history selection (e.g. Space). */
+function readKeyboardEventKey(event) {
+    if (typeof event.key === 'string' && event.key.length > 0) {
+        return event.key;
+    }
+    switch (event.code) {
+        case 'Space': return ' ';
+        case 'Enter': return 'Enter';
+        case 'Escape': return 'Escape';
+        case 'Backspace': return 'Backspace';
+        case 'Delete': return 'Delete';
+        case 'Tab': return 'Tab';
+        case 'ArrowUp': return 'ArrowUp';
+        case 'ArrowDown': return 'ArrowDown';
+        case 'ArrowLeft': return 'ArrowLeft';
+        case 'ArrowRight': return 'ArrowRight';
+        default:
+            if (event.code.startsWith('Key'))
+                return event.code.slice(3);
+            if (event.code.startsWith('Digit'))
+                return event.code.slice(5);
+            return event.code;
+    }
+}
+export function detectKeybindingPlatform() {
+    if (typeof navigator === 'undefined')
+        return 'linux';
+    const platform = navigator.platform.toLowerCase();
+    if (platform.includes('mac'))
+        return 'mac';
+    if (platform.includes('win'))
+        return 'windows';
+    return 'linux';
+}
+export function normalizeKeybinding(keys, platform) {
+    const parts = keys.split('+').map((part) => part.trim()).filter(Boolean);
+    const key = parts.pop();
+    if (!key)
+        return '';
+    const modifiers = new Set();
+    for (const modifier of parts) {
+        const lower = modifier.toLowerCase();
+        if (lower === 'mod')
+            modifiers.add(platform === 'mac' ? 'Meta' : 'Ctrl');
+        else if (lower === 'cmd' || lower === 'command' || lower === 'meta')
+            modifiers.add('Meta');
+        else if (lower === 'ctrl' || lower === 'control')
+            modifiers.add('Ctrl');
+        else if (lower === 'alt' || lower === 'option')
+            modifiers.add('Alt');
+        else if (lower === 'shift')
+            modifiers.add('Shift');
+    }
+    const ordered = ['Ctrl', 'Meta', 'Alt', 'Shift'].filter((modifier) => modifiers.has(modifier));
+    return [...ordered, normalizeKey(key)].join('+');
+}
+export function isEditableEventTarget(target) {
+    if (!(target instanceof Element))
+        return false;
+    if (target instanceof HTMLInputElement || target instanceof HTMLTextAreaElement || target instanceof HTMLSelectElement) {
+        return true;
+    }
+    return target.closest('[contenteditable]:not([contenteditable="false"]),[role="textbox"]') !== null;
+}
+export function normalizeKeyboardEvent(event, platform = detectKeybindingPlatform()) {
+    const modifiers = [
+        event.ctrlKey ? 'Ctrl' : '',
+        event.metaKey ? 'Meta' : '',
+        event.altKey ? 'Alt' : '',
+        event.shiftKey ? 'Shift' : '',
+    ].filter(Boolean);
+    return {
+        key: [...modifiers, normalizeKey(readKeyboardEventKey(event))].join('+'),
+        editable: isEditableEventTarget(event.composedPath()[0] ?? event.target),
+        composing: event.isComposing || event.keyCode === 229,
+    };
+}
+export function matchesKeybinding(event, keys, platform) {
+    return event.key === normalizeKeybinding(keys, platform);
+}
+function bindingMatches(binding, normalized, platform) {
+    const keys = typeof binding.keys === 'string' ? [binding.keys] : binding.keys;
+    return keys.some((key) => matchesKeybinding(normalized, key, platform));
+}
+export function resolveKeybinding(input) {
+    const scopeOrder = [...input.scopes, APPLICATION_KEYBINDING_SCOPE];
+    const context = { event: input.event, scopes: input.scopes };
+    for (const scope of scopeOrder) {
+        const candidates = input.bindings
+            .filter((binding) => binding.scope === scope)
+            .filter((binding) => bindingMatches(binding, input.normalized, input.platform))
+            .filter((binding) => !binding.when || binding.when(context))
+            .filter((binding) => !input.normalized.editable || binding.allowInEditable)
+            .filter((binding) => !input.normalized.composing || binding.allowDuringComposition)
+            .sort((a, b) => (b.priority ?? 0) - (a.priority ?? 0)
+            || b.registrationOrder - a.registrationOrder);
+        const binding = candidates[0];
+        if (!binding)
+            continue;
+        if (!input.isCommandEnabled(binding.commandId)) {
+            return { status: 'claimed-disabled', binding };
+        }
+        return { status: 'matched', binding };
+    }
+    if (input.normalized.composing)
+        return { status: 'passthrough', reason: 'composition' };
+    if (input.normalized.editable)
+        return { status: 'passthrough', reason: 'editable' };
+    return { status: 'unclaimed' };
+}
+export function createContextualKeybindings(commands, options = {}) {
+    const platform = options.platform ?? detectKeybindingPlatform();
+    const bindings = new Set();
+    const scopes = new WeakMap();
+    let registrationOrder = 0;
+    const scopePath = (event) => {
+        const result = [];
+        for (const target of event.composedPath()) {
+            if (!(target instanceof Element))
+                continue;
+            const scopeId = scopes.get(target);
+            if (scopeId && !result.includes(scopeId))
+                result.push(scopeId);
+        }
+        return result;
+    };
+    const resolve = (event) => {
+        const normalized = normalizeKeyboardEvent(event, platform);
+        return resolveKeybinding({
+            event,
+            normalized,
+            scopes: scopePath(event),
+            bindings: Array.from(bindings),
+            platform,
+            isCommandEnabled(commandId) {
+                const command = commands.get(commandId);
+                if (!command)
+                    return false;
+                try {
+                    return !command.when || command.when();
+                }
+                catch {
+                    return false;
+                }
+            },
+        });
+    };
+    return {
+        register(binding) {
+            const registered = { ...binding, registrationOrder: registrationOrder++ };
+            bindings.add(registered);
+            return () => { bindings.delete(registered); };
+        },
+        registerScope(element, scopeId) {
+            scopes.set(element, scopeId);
+            return () => {
+                if (scopes.get(element) === scopeId)
+                    scopes.delete(element);
+            };
+        },
+        resolve,
+        handle(event) {
+            const result = resolve(event);
+            if (result.status !== 'matched' && result.status !== 'claimed-disabled')
+                return result;
+            if (result.binding.preventDefault !== 'never')
+                event.preventDefault();
+            event.stopImmediatePropagation();
+            if (result.status === 'claimed-disabled')
+                return result;
+            void commands.execute(result.binding.commandId).catch((error) => {
+                options.onCommandError?.(error, result.binding.commandId);
+            });
+            return { status: 'handled', binding: result.binding };
+        },
+        dispose() {
+            bindings.clear();
+        },
+    };
+}

package/dist/package/node/core/extension-foundation/bus.js

@@ -0,0 +1,3 @@
+// Thin re-export shell — implementation lives in
+// @forgeax/extension-platform (ADR 0026).
+export { EventBus } from '@forgeax/extension-platform/base';

package/dist/package/node/core/extension-foundation/capabilities.js

@@ -0,0 +1,3 @@
+// Thin re-export shell — implementation lives in
+// @forgeax/extension-platform (ADR 0026).
+export { CapabilityRegistry, createCapabilityRegistry, } from '@forgeax/extension-platform/platform';

package/dist/package/node/core/extension-foundation/commands.js

@@ -0,0 +1,3 @@
+// Thin re-export shell — implementation lives in
+// @forgeax/extension-platform (ADR 0026).
+export { createCommandsRegistry } from '@forgeax/extension-platform/platform';

package/dist/package/node/core/extension-foundation/context-keys.js

@@ -0,0 +1,3 @@
+// Thin re-export shell — implementation lives in
+// @forgeax/extension-platform (ADR 0026).
+export { createContextKeys } from '@forgeax/extension-platform/platform';

package/dist/package/node/core/extension-foundation/contribution-registry.js

@@ -0,0 +1,3 @@
+// Thin re-export shell — implementation lives in
+// @forgeax/extension-platform (ADR 0026).
+export { createContributionRegistry } from '@forgeax/extension-platform/platform';

package/dist/package/node/core/extension-foundation/errors.js

@@ -0,0 +1,3 @@
+// Thin re-export shell — implementation lives in
+// @forgeax/extension-platform (ADR 0026).
+export { ExtensionConflictError, ExtensionSetupError, } from '@forgeax/extension-platform/platform';

package/dist/package/node/core/extension-foundation/index.js

@@ -0,0 +1,9 @@
+// packages/interface/src/core/extension-foundation/index.ts
+export * from './types.js';
+export * from './errors.js';
+export * from './bus.js';
+export * from './commands.js';
+export * from './context-keys.js';
+export * from './storage.js';
+export * from './capabilities.js';
+export * from './loader.js';

package/dist/package/node/core/extension-foundation/loader.js

@@ -0,0 +1,3 @@
+// Thin re-export shell — implementation lives in
+// @forgeax/extension-platform (ADR 0026).
+export { ExtensionLoader, createExtensionLoader, } from '@forgeax/extension-platform/extensions';

package/dist/package/node/core/extension-foundation/storage.js

@@ -0,0 +1,3 @@
+// Thin re-export shell — implementation lives in
+// @forgeax/extension-platform (ADR 0026).
+export { createStorageApi } from '@forgeax/extension-platform/platform';

package/dist/package/node/core/extension-foundation/types.js

@@ -0,0 +1 @@
+export {};

package/dist/package/node/core/extensions/builtin-commands.js

@@ -0,0 +1,256 @@
+// packages/interface/src/core/extensions/builtin-commands.ts
+//
+// Ports `lib/builtin-actions.ts` to the command bus. The zustand store is
+// still the state SSOT (until PR 3); the actions here are thin wrappers
+// that (a) live on the command bus (so keyboard / palette / iframe all
+// hit the same entry) and (b) still call `useShellStore` / clients under
+// the hood.
+//
+// Static imports are used instead of the lazy `require(...)` pattern the
+// spec suggested — the interface is ESM ("type": "module") and no cycle
+// exists: this file is a leaf plugin, nothing else imports it. Direct
+// static imports keep the concept count lower.
+import { useShellStore } from '../../store.js';
+import { bumpDockResetEpoch } from '../../components/DockShell/dockResetEpoch.js';
+import { chatWidthStore, CHAT_DEFAULT_WIDTH } from '../../components/ChatColumn/useChatWidth.js';
+import { isDockPanelVisible } from '@forgeax/app-shell/dock';
+import { useFeedbackStore } from '../../components/Feedback/store.js';
+import { isTauri } from '../../lib/platform/runtime.js';
+import { getSessionClient, hasSessionClient } from '../../store-parts/session-client.js';
+import { executeFocusedTextEditAction } from '../../lib/text-edit-actions.js';
+const getState = () => useShellStore.getState();
+export const builtinCommandsExtension = {
+    id: 'builtin-commands',
+    version: '1.0.0',
+    requires: ['commands'],
+    setup(ctx) {
+        const { registerCommand } = ctx;
+        const cleanups = [];
+        const registerTextEditCommand = (id, title, action) => {
+            cleanups.push(registerCommand({
+                id,
+                title,
+                execute: async () => ({
+                    status: await executeFocusedTextEditAction(action) ? 'completed' : 'rejected',
+                }),
+            }));
+        };
+        registerTextEditCommand('text.cut', '剪切输入框选区', 'cut');
+        registerTextEditCommand('text.copy', '复制输入框选区', 'copy');
+        registerTextEditCommand('text.paste', '粘贴到输入框', 'paste');
+        cleanups.push(registerCommand({
+            id: 'app.panel.open',
+            title: 'Open (or focus) a dock panel by id',
+            execute: (args) => {
+                const id = args?.id;
+                if (!id)
+                    throw new Error('app.panel.open: missing { id }');
+                ctx.bus.emit('panel:open', { id });
+                return { status: 'completed' };
+            },
+        }));
+        cleanups.push(registerCommand({
+            id: 'app.panel.reveal',
+            title: 'Reveal a dock panel wherever it lives (grid, closed, or edge drawer)',
+            execute: (args) => {
+                const id = args?.id;
+                if (!id)
+                    throw new Error('app.panel.reveal: missing { id }');
+                ctx.bus.emit('panel:reveal', { id });
+                return { status: 'completed' };
+            },
+        }));
+        cleanups.push(registerCommand({
+            id: 'app.panel.focus',
+            title: 'Focus an existing dock panel by id (no reopen)',
+            execute: (args) => {
+                const id = args?.id;
+                if (!id)
+                    throw new Error('app.panel.focus: missing { id }');
+                ctx.bus.emit('panel:focus', { id });
+                return { status: 'completed' };
+            },
+        }));
+        cleanups.push(registerCommand({
+            id: 'app.panel.close',
+            title: 'Close a dock panel by id (no-op if not open)',
+            execute: (args) => {
+                const id = args?.id;
+                if (!id)
+                    throw new Error('app.panel.close: missing { id }');
+                ctx.bus.emit('panel:close', { id });
+                return { status: 'completed' };
+            },
+        }));
+        cleanups.push(registerCommand({
+            id: 'app.panel.toggle',
+            title: 'Toggle a dock panel by id (open if hidden, close if visible)',
+            execute: (args) => {
+                const id = args?.id;
+                if (!id)
+                    throw new Error('app.panel.toggle: missing { id }');
+                // Visibility comes from App Shell's shared mount registry, which
+                // DockRegion updates from Dockview lifecycle events. This product
+                // command only chooses which existing event to emit.
+                if (isDockPanelVisible(id))
+                    ctx.bus.emit('panel:close', { id });
+                else
+                    ctx.bus.emit('panel:open', { id });
+                return { status: 'completed' };
+            },
+        }));
+        cleanups.push(registerCommand({
+            id: 'app.open_url',
+            title: 'Open an external http(s) URL in the OS default browser',
+            execute: async (args) => {
+                const url = args?.url;
+                if (typeof url !== 'string' || !url)
+                    throw new Error('app.open_url: missing { url }');
+                const trimmed = url.trim();
+                if (!/^https?:\/\//i.test(trimmed)) {
+                    throw new Error(`app.open_url: only http(s) URLs are allowed, got: ${trimmed}`);
+                }
+                if (isTauri()) {
+                    // Prefer the plugin-shell opener so the URL goes to the OS default
+                    // browser, not the tauri webview. If the capability isn't granted the
+                    // call rejects — fall through to window.open in that case.
+                    try {
+                        const shell = await import('@tauri-apps/plugin-shell');
+                        await shell.open(trimmed);
+                        return { status: 'completed' };
+                    }
+                    catch { /* fall through */ }
+                }
+                try {
+                    window.open(trimmed, '_blank', 'noopener');
+                }
+                catch { /* noop */ }
+                return { status: 'completed' };
+            },
+        }));
+        cleanups.push(registerCommand({
+            id: 'app.dock.reset',
+            title: 'Reset dock layout',
+            execute: () => {
+                // Epoch first so DockRegions that are not yet subscribed / onReady can
+                // still apply this reset exactly once when they become ready.
+                bumpDockResetEpoch();
+                ctx.bus.emit('dock:reset', {});
+                // The chat column's WIDTH is a shell store (ChatDockResizer), not part of
+                // the dockview layout the dock:reset rebuild restores — reset it here at
+                // the single command entry point so 重置布局 also restores chat's width.
+                try {
+                    chatWidthStore.setSize(CHAT_DEFAULT_WIDTH);
+                }
+                catch { /* noop */ }
+                return { status: 'completed' };
+            },
+        }));
+        cleanups.push(registerCommand({
+            id: 'app.dock.layoutToggle',
+            title: 'Open the dock layout menu',
+            execute: (args) => {
+                ctx.bus.emit('dock:layout-toggle', args ?? {});
+                return { status: 'completed' };
+            },
+        }));
+        cleanups.push(registerCommand({
+            id: 'panel.toggle_sidebar',
+            title: '折叠/展开侧栏',
+            execute: () => { getState().toggleSidebar(); return { status: 'completed' }; },
+        }));
+        cleanups.push(registerCommand({
+            id: 'panel.toggle_chatpanel',
+            title: '折叠/展开聊天面板',
+            execute: () => { getState().toggleChatpanel(); return { status: 'completed' }; },
+        }));
+        cleanups.push(registerCommand({
+            id: 'app.set_fullscreen',
+            title: '沉浸模式',
+            execute: (args) => {
+                const value = args?.value ?? false;
+                getState().setFullscreen(value);
+                return { status: 'completed', value };
+            },
+        }));
+        cleanups.push(registerCommand({
+            id: 'overlay.open',
+            title: '打开浮层',
+            execute: (args) => {
+                const p = args;
+                if (!p?.id)
+                    throw new Error('overlay.open: missing { id }');
+                getState().openOverlay(p.id, p.param);
+                return { status: 'completed' };
+            },
+        }));
+        cleanups.push(registerCommand({
+            id: 'overlay.close',
+            title: '关闭浮层',
+            execute: () => { getState().closeOverlay(); return { status: 'completed' }; },
+        }));
+        cleanups.push(registerCommand({
+            id: 'feedback.open',
+            title: '打开反馈面板',
+            execute: () => {
+                useFeedbackStore.getState().openPanel('write');
+                return { status: 'completed' };
+            },
+        }));
+        cleanups.push(registerCommand({
+            id: 'session.reconnect',
+            title: '重连当前会话',
+            execute: () => {
+                const sid = getState().activeSid;
+                if (!sid || !hasSessionClient())
+                    throw new Error('session.reconnect: no active session client');
+                const client = getSessionClient();
+                client.disconnectForgeaXWs();
+                client.connectForgeaXWs(sid);
+                return { status: 'completed' };
+            },
+        }));
+        // Game flows — a game is exactly one game directory.
+        cleanups.push(registerCommand({
+            id: 'game.open-directory',
+            title: '打开游戏目录',
+            execute: () => { getState().openGameDirectoryModal(); return { status: 'completed' }; },
+        }));
+        cleanups.push(registerCommand({
+            id: 'game.new',
+            title: '新建游戏',
+            execute: () => { getState().openGameModal(); return { status: 'completed' }; },
+        }));
+        cleanups.push(registerCommand({
+            id: 'game.open',
+            title: '打开游戏（游戏列表）',
+            execute: () => { getState().setGameSwitcherOpen(true); return { status: 'completed' }; },
+        }));
+        // game.pick — switch directly to a specific game by slug. Drives the File →
+        // 打开最近 submenu (each recent-game row dispatches this with its slug). Same
+        // store.setActiveGame mechanism the game.switch action + game-list modal use —
+        // no second code path, just a command-bus entry so the menu can reach it.
+        cleanups.push(registerCommand({
+            id: 'game.pick',
+            title: '切换到游戏',
+            execute: (args) => {
+                const slug = args?.slug;
+                if (typeof slug !== 'string' || !slug)
+                    return { status: 'rejected' };
+                void getState().setActiveGame(slug);
+                return { status: 'completed' };
+            },
+        }));
+        // Remaining actions (extension.list / extension.open /
+        // console.clear / console.read / network.clear / session.* / game.switch)
+        // stay in lib/builtin-actions.ts for now — they're consumed by
+        // action-registry (AI's tool registry). PR 3 will unify.
+        return () => {
+            // Reverse order so first-registered is torn down last (T9 fixup lesson).
+            // `.slice()` clones the array — never mutate the closed-over `cleanups`
+            // directly with `.reverse()` or repeat unloads would break.
+            for (const c of cleanups.slice().reverse())
+                c();
+        };
+    },
+};