dexto 1.5.8 → 1.6.1

package/dist/cli/ink-cli/components/overlays/SoundsSelector.js

@@ -0,0 +1,566 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+/**
+ * SoundsSelector Component
+ * Interactive overlay for configuring sound notifications and selecting built-in sounds.
+ *
+ * Built-in sounds are copied into the Dexto sounds directory (typically ~/.dexto/sounds/builtins/)
+ * and selected via preferences.yml using paths relative to that directory (e.g., builtins/coin.wav).
+ *
+ * This reuses the existing sound resolution logic in soundNotification.ts.
+ */
+import { useCallback, useEffect, useImperativeHandle, useMemo, useRef, useState, forwardRef, } from 'react';
+import { Box, Text } from 'ink';
+import { fileURLToPath } from 'node:url';
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import { BaseSelector } from '../base/BaseSelector.js';
+import { CUSTOM_SOUND_EXTENSIONS, getDefaultSoundSpec, playNotificationSound, playSoundFile, } from '../../utils/soundNotification.js';
+import { useSoundService } from '../../contexts/index.js';
+import { getDextoGlobalPath, globalPreferencesExist, loadGlobalPreferences, updateGlobalPreferences, } from '@dexto/agent-management';
+const BUILTIN_SOUNDS = [
+    {
+        id: 'coin',
+        name: 'Coin',
+        filename: 'coin.wav',
+    },
+    {
+        id: 'confirm',
+        name: 'Confirm',
+        filename: 'confirm.wav',
+    },
+    {
+        id: 'ping',
+        name: 'Ping',
+        filename: 'ping.wav',
+    },
+    {
+        id: 'powerup',
+        name: 'Power Up',
+        filename: 'powerup.wav',
+    },
+    {
+        id: 'chime',
+        name: 'Chime',
+        filename: 'chime.wav',
+    },
+    {
+        id: 'levelup',
+        name: 'Level Up',
+        filename: 'levelup.wav',
+    },
+    {
+        id: 'boot',
+        name: 'Boot',
+        filename: 'boot.wav',
+    },
+    {
+        id: 'startup',
+        name: 'Startup',
+        filename: 'startup.wav',
+    },
+    {
+        id: 'success',
+        name: 'Success',
+        filename: 'success.wav',
+    },
+    {
+        id: 'win',
+        name: 'Win',
+        filename: 'win.wav',
+    },
+    {
+        id: 'treasure',
+        name: 'Treasure Chest',
+        filename: 'treasure.wav',
+    },
+];
+const DEFAULT_CONFIG = {
+    enabled: true,
+    onStartup: false,
+    onApprovalRequired: true,
+    onTaskComplete: true,
+};
+function getSoundEnabledKey(soundType) {
+    switch (soundType) {
+        case 'startup':
+            return 'onStartup';
+        case 'approval':
+            return 'onApprovalRequired';
+        case 'complete':
+            return 'onTaskComplete';
+    }
+}
+function getSoundFileKey(soundType) {
+    switch (soundType) {
+        case 'startup':
+            return 'startupSoundFile';
+        case 'approval':
+            return 'approvalSoundFile';
+        case 'complete':
+            return 'completeSoundFile';
+    }
+}
+function selectionLabel(soundType, selection) {
+    if (selection.kind === 'system')
+        return soundType === 'startup' ? 'Startup' : 'System';
+    const normalizedRelative = selection.relativePath.replaceAll('\\', '/');
+    const builtinFilename = normalizedRelative.startsWith('builtins/')
+        ? normalizedRelative.slice('builtins/'.length)
+        : null;
+    if (builtinFilename) {
+        const builtin = BUILTIN_SOUNDS.find((s) => s.filename === builtinFilename);
+        if (builtin)
+            return builtin.name;
+    }
+    return normalizedRelative.replace(/\.[^/.]+$/, '');
+}
+function getAllowedCustomSoundExtensions() {
+    switch (process.platform) {
+        case 'win32':
+            return new Set(['.wav']);
+        case 'linux':
+            return new Set(['.wav', '.ogg', '.oga']);
+        default:
+            return new Set(CUSTOM_SOUND_EXTENSIONS);
+    }
+}
+async function listCustomSoundFiles(soundsDir) {
+    const allowedExtensions = getAllowedCustomSoundExtensions();
+    const results = [];
+    const walk = async (dir) => {
+        let entries;
+        try {
+            entries = await fs.readdir(dir, { withFileTypes: true });
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                return;
+            throw error;
+        }
+        for (const entry of entries) {
+            if (entry.name.startsWith('.'))
+                continue;
+            const absPath = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                if (dir === soundsDir && entry.name === 'builtins')
+                    continue;
+                await walk(absPath);
+                continue;
+            }
+            if (!entry.isFile())
+                continue;
+            const ext = path.extname(entry.name).toLowerCase();
+            if (!allowedExtensions.has(ext))
+                continue;
+            const relative = path.relative(soundsDir, absPath);
+            if (relative.startsWith('..') || path.isAbsolute(relative))
+                continue;
+            results.push(relative.split(path.sep).join('/'));
+        }
+    };
+    await walk(soundsDir);
+    return results.sort((a, b) => a.localeCompare(b));
+}
+function formatCustomSoundLabel(relativePath) {
+    return relativePath.replaceAll('\\', '/').replace(/\.[^/.]+$/, '');
+}
+function resolveSelection(soundType, config) {
+    const configuredRelativePath = config[getSoundFileKey(soundType)];
+    if (configuredRelativePath) {
+        return { kind: 'file', relativePath: configuredRelativePath };
+    }
+    return { kind: 'system' };
+}
+const SoundsSelector = forwardRef(function SoundsSelector({ isVisible, onClose }, ref) {
+    const soundService = useSoundService();
+    const baseSelectorRef = useRef(null);
+    const [viewMode, setViewMode] = useState('main');
+    const [selectedIndex, setSelectedIndex] = useState(0);
+    const [pickAction, setPickAction] = useState('listen');
+    const [isLoading, setIsLoading] = useState(false);
+    const [isApplying, setIsApplying] = useState(false);
+    const [error, setError] = useState(null);
+    const [canPersistPreferences, setCanPersistPreferences] = useState(false);
+    const [config, setConfig] = useState(DEFAULT_CONFIG);
+    const [customSoundFiles, setCustomSoundFiles] = useState([]);
+    const [approvalSelection, setApprovalSelection] = useState({
+        kind: 'system',
+    });
+    const [completeSelection, setCompleteSelection] = useState({
+        kind: 'system',
+    });
+    const [startupSelection, setStartupSelection] = useState({
+        kind: 'system',
+    });
+    const configRef = useRef(config);
+    configRef.current = config;
+    const closeOrBack = useCallback(() => {
+        if (viewMode === 'main') {
+            onClose();
+            return;
+        }
+        setViewMode('main');
+        setSelectedIndex(0);
+        setError(null);
+    }, [onClose, viewMode]);
+    useImperativeHandle(ref, () => ({
+        handleInput: (input, key) => {
+            if (!isVisible)
+                return false;
+            if (viewMode !== 'main') {
+                if (key.leftArrow) {
+                    setPickAction('listen');
+                    return true;
+                }
+                if (key.rightArrow) {
+                    setPickAction('select');
+                    return true;
+                }
+            }
+            return baseSelectorRef.current?.handleInput(input, key) ?? false;
+        },
+    }), [isVisible, viewMode]);
+    const builtinSoundPaths = useMemo(() => {
+        return BUILTIN_SOUNDS.map((sound) => ({
+            ...sound,
+            absPath: fileURLToPath(new URL(`../../../assets/sounds/${sound.filename}`, import.meta.url)),
+        }));
+    }, []);
+    const refreshSelections = useCallback((nextConfig) => {
+        setStartupSelection(resolveSelection('startup', nextConfig));
+        setApprovalSelection(resolveSelection('approval', nextConfig));
+        setCompleteSelection(resolveSelection('complete', nextConfig));
+    }, []);
+    // Load preferences + built-in sounds when becoming visible
+    useEffect(() => {
+        if (!isVisible)
+            return;
+        let cancelled = false;
+        setIsLoading(true);
+        setIsApplying(false);
+        setError(null);
+        setViewMode('main');
+        setSelectedIndex(0);
+        const run = async () => {
+            // Load preferences (optional)
+            const prefsExist = globalPreferencesExist();
+            setCanPersistPreferences(prefsExist);
+            let nextConfig = DEFAULT_CONFIG;
+            if (prefsExist) {
+                try {
+                    const preferences = await loadGlobalPreferences();
+                    nextConfig = {
+                        enabled: preferences.sounds?.enabled ?? nextConfig.enabled,
+                        onStartup: preferences.sounds?.onStartup ?? nextConfig.onStartup,
+                        startupSoundFile: preferences.sounds?.startupSoundFile,
+                        onApprovalRequired: preferences.sounds?.onApprovalRequired ??
+                            nextConfig.onApprovalRequired,
+                        approvalSoundFile: preferences.sounds?.approvalSoundFile,
+                        onTaskComplete: preferences.sounds?.onTaskComplete ?? nextConfig.onTaskComplete,
+                        completeSoundFile: preferences.sounds?.completeSoundFile,
+                    };
+                }
+                catch (err) {
+                    // Non-fatal: allow selection changes, but toggles won't persist
+                    setCanPersistPreferences(false);
+                    if (!cancelled) {
+                        setError(`Failed to load preferences: ${err instanceof Error ? err.message : String(err)}`);
+                    }
+                }
+            }
+            if (!cancelled) {
+                setConfig(nextConfig);
+                soundService?.setConfig(nextConfig);
+                refreshSelections(nextConfig);
+            }
+            const soundsDir = getDextoGlobalPath('sounds');
+            try {
+                const files = await listCustomSoundFiles(soundsDir);
+                if (!cancelled)
+                    setCustomSoundFiles(files);
+            }
+            catch (err) {
+                if (!cancelled) {
+                    setCustomSoundFiles([]);
+                    setError(`Failed to load custom sounds: ${err instanceof Error ? err.message : String(err)}`);
+                }
+            }
+        };
+        void run()
+            .catch((err) => {
+            if (!cancelled) {
+                setError(err instanceof Error ? err.message : String(err));
+            }
+        })
+            .finally(() => {
+            if (!cancelled)
+                setIsLoading(false);
+        });
+        return () => {
+            cancelled = true;
+        };
+    }, [isVisible, refreshSelections, soundService]);
+    const mainItems = useMemo(() => [
+        { type: 'enabled', id: 'enabled' },
+        {
+            type: 'pick',
+            id: 'pick-startup',
+            soundType: 'startup',
+            label: 'startup sound',
+        },
+        {
+            type: 'pick',
+            id: 'pick-approval',
+            soundType: 'approval',
+            label: 'approval sound',
+        },
+        {
+            type: 'pick',
+            id: 'pick-complete',
+            soundType: 'complete',
+            label: 'completion sound',
+        },
+    ], []);
+    const pickSoundType = viewMode === 'pick-startup'
+        ? 'startup'
+        : viewMode === 'pick-approval'
+            ? 'approval'
+            : viewMode === 'pick-complete'
+                ? 'complete'
+                : null;
+    const pickItems = useMemo(() => {
+        if (!pickSoundType)
+            return [];
+        const current = pickSoundType === 'startup'
+            ? startupSelection
+            : pickSoundType === 'approval'
+                ? approvalSelection
+                : completeSelection;
+        const enabledKey = getSoundEnabledKey(pickSoundType);
+        const isEnabled = config[enabledKey];
+        const normalizedRelative = current.kind === 'file' ? current.relativePath.replaceAll('\\', '/') : null;
+        const items = [
+            {
+                type: 'off',
+                id: 'off',
+                label: 'Off',
+                isCurrent: !isEnabled,
+            },
+            {
+                type: 'default',
+                id: 'default',
+                label: 'Default',
+                isCurrent: isEnabled && current.kind === 'system',
+            },
+            ...builtinSoundPaths.map((sound) => ({
+                type: 'builtin',
+                id: sound.id,
+                label: sound.name,
+                isCurrent: isEnabled &&
+                    normalizedRelative === path.posix.join('builtins', sound.filename),
+            })),
+            ...customSoundFiles.map((relativePath) => ({
+                type: 'file',
+                id: relativePath,
+                relativePath,
+                label: formatCustomSoundLabel(relativePath),
+                isCurrent: isEnabled && normalizedRelative === relativePath.replaceAll('\\', '/'),
+            })),
+        ];
+        return items;
+    }, [
+        approvalSelection,
+        builtinSoundPaths,
+        customSoundFiles,
+        completeSelection,
+        config,
+        pickSoundType,
+        startupSelection,
+    ]);
+    const items = viewMode === 'main' ? mainItems : pickItems;
+    const applyConfigUpdate = useCallback(async (partial) => {
+        const previousConfig = configRef.current;
+        const nextConfig = { ...previousConfig, ...partial };
+        setConfig(nextConfig);
+        soundService?.setConfig(partial);
+        refreshSelections(nextConfig);
+        if (!canPersistPreferences) {
+            return;
+        }
+        try {
+            await updateGlobalPreferences({ sounds: partial });
+        }
+        catch (err) {
+            setConfig(previousConfig);
+            soundService?.setConfig(previousConfig);
+            refreshSelections(previousConfig);
+            setError(err instanceof Error ? err.message : String(err));
+        }
+    }, [canPersistPreferences, refreshSelections, soundService]);
+    const ensureBuiltinSoundFile = useCallback(async (soundId) => {
+        const soundsDir = getDextoGlobalPath('sounds');
+        const builtinsDir = path.join(soundsDir, 'builtins');
+        await fs.mkdir(builtinsDir, { recursive: true });
+        const builtin = builtinSoundPaths.find((s) => s.id === soundId);
+        if (!builtin) {
+            throw new Error(`Unknown built-in sound: ${soundId}`);
+        }
+        const destPath = path.join(builtinsDir, builtin.filename);
+        await fs.copyFile(builtin.absPath, destPath);
+        return path.posix.join('builtins', builtin.filename);
+    }, [builtinSoundPaths]);
+    const previewPickItem = useCallback((item) => {
+        if (!pickSoundType)
+            return;
+        if (item.type === 'off') {
+            return;
+        }
+        if (item.type === 'default') {
+            const spec = getDefaultSoundSpec(pickSoundType);
+            if (spec)
+                playSoundFile(spec);
+            return;
+        }
+        if (item.type === 'builtin') {
+            const builtin = builtinSoundPaths.find((s) => s.id === item.id);
+            if (builtin) {
+                playSoundFile(builtin.absPath);
+            }
+            return;
+        }
+        if (item.type === 'file') {
+            const soundsDir = path.normalize(getDextoGlobalPath('sounds'));
+            const resolved = path.normalize(path.resolve(soundsDir, item.relativePath));
+            if (resolved === soundsDir || resolved.startsWith(soundsDir + path.sep)) {
+                playSoundFile(resolved);
+            }
+        }
+    }, [builtinSoundPaths, pickSoundType]);
+    const handleSelect = useCallback(async (item) => {
+        if (isApplying || isLoading)
+            return;
+        setIsApplying(true);
+        setError(null);
+        try {
+            if (item.type === 'enabled') {
+                await applyConfigUpdate({ enabled: !configRef.current.enabled });
+                return;
+            }
+            if (item.type === 'pick') {
+                setPickAction('listen');
+                setViewMode(item.id);
+                setSelectedIndex(0);
+                return;
+            }
+            if (item.type === 'off' ||
+                item.type === 'default' ||
+                item.type === 'builtin' ||
+                item.type === 'file') {
+                if (!pickSoundType)
+                    return;
+                const enabledKey = getSoundEnabledKey(pickSoundType);
+                const fileKey = getSoundFileKey(pickSoundType);
+                if (pickAction === 'listen') {
+                    previewPickItem(item);
+                    return;
+                }
+                if (item.type === 'off') {
+                    await applyConfigUpdate({ [enabledKey]: false });
+                    setViewMode('main');
+                    setSelectedIndex(0);
+                    return;
+                }
+                if (item.type === 'default') {
+                    const partial = {
+                        [enabledKey]: true,
+                        [fileKey]: undefined,
+                    };
+                    await applyConfigUpdate(partial);
+                    playNotificationSound(pickSoundType, {
+                        ...configRef.current,
+                        ...partial,
+                    });
+                }
+                else if (item.type === 'builtin') {
+                    const relativePath = await ensureBuiltinSoundFile(item.id);
+                    const partial = {
+                        [enabledKey]: true,
+                        [fileKey]: relativePath,
+                    };
+                    await applyConfigUpdate(partial);
+                    playNotificationSound(pickSoundType, {
+                        ...configRef.current,
+                        ...partial,
+                    });
+                }
+                else {
+                    const partial = {
+                        [enabledKey]: true,
+                        [fileKey]: item.relativePath,
+                    };
+                    await applyConfigUpdate(partial);
+                    playNotificationSound(pickSoundType, {
+                        ...configRef.current,
+                        ...partial,
+                    });
+                }
+                setViewMode('main');
+                setSelectedIndex(0);
+                return;
+            }
+        }
+        catch (err) {
+            setError(err instanceof Error ? err.message : String(err));
+        }
+        finally {
+            setIsApplying(false);
+        }
+    }, [
+        applyConfigUpdate,
+        isApplying,
+        isLoading,
+        pickAction,
+        pickSoundType,
+        previewPickItem,
+        ensureBuiltinSoundFile,
+    ]);
+    const formatItem = useCallback((item, isSelected) => {
+        if (item.type === 'enabled') {
+            return (_jsxs(Text, { wrap: "truncate-end", children: [_jsxs(Text, { color: isSelected ? 'cyan' : 'gray', bold: isSelected, children: ["sounds:", ' '] }), _jsx(Text, { color: config.enabled ? 'green' : 'gray', bold: isSelected, children: config.enabled ? 'On' : 'Off' })] }));
+        }
+        if (item.type === 'pick') {
+            const enabled = item.soundType === 'startup'
+                ? config.onStartup
+                : item.soundType === 'approval'
+                    ? config.onApprovalRequired
+                    : config.onTaskComplete;
+            const selection = item.soundType === 'startup'
+                ? startupSelection
+                : item.soundType === 'approval'
+                    ? approvalSelection
+                    : completeSelection;
+            const currentLabel = enabled
+                ? selectionLabel(item.soundType, selection)
+                : 'Off';
+            return (_jsxs(Text, { color: isSelected ? 'cyan' : 'gray', bold: isSelected, wrap: "truncate-end", children: [item.label, ": ", currentLabel] }));
+        }
+        if (item.type === 'off' ||
+            item.type === 'default' ||
+            item.type === 'builtin' ||
+            item.type === 'file') {
+            return (_jsxs(Box, { flexDirection: "row", children: [_jsxs(Box, { flexGrow: 1, flexDirection: "row", children: [_jsx(Text, { color: "green", children: item.isCurrent ? '* ' : '  ' }), _jsx(Text, { color: isSelected ? 'cyan' : 'gray', bold: isSelected, wrap: "truncate-end", children: item.label })] }), isSelected && (_jsxs(Box, { flexDirection: "row", marginLeft: 1, children: [_jsxs(Text, { inverse: pickAction === 'listen', bold: pickAction === 'listen', children: [' ', "Listen", ' '] }), _jsx(Text, { children: " " }), _jsxs(Text, { inverse: pickAction === 'select', bold: pickAction === 'select', children: [' ', "Select", ' '] })] }))] }));
+        }
+        return null;
+    }, [approvalSelection, completeSelection, config, pickAction, startupSelection]);
+    const title = viewMode === 'main'
+        ? 'Sounds'
+        : pickSoundType === 'startup'
+            ? 'Select Startup Sound'
+            : pickSoundType === 'approval'
+                ? 'Select Approval Sound'
+                : 'Select Completion Sound';
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(BaseSelector, { ref: baseSelectorRef, items: items, isVisible: isVisible, isLoading: isLoading, loadingMessage: "Loading sound settings...", selectedIndex: selectedIndex, onSelectIndex: setSelectedIndex, onSelect: (item) => void handleSelect(item), onClose: closeOrBack, formatItem: formatItem, title: title, instructionsOverride: viewMode === 'main'
+                    ? '↑↓ navigate • Enter toggle/select • Esc close'
+                    : `↑↓ navigate • ←/→ Listen/Select • Enter ${pickAction === 'listen' ? 'preview' : 'select'} • Esc back`, borderColor: "magenta", emptyMessage: "No options available" }), error && (_jsx(Box, { marginTop: 1, children: _jsx(Text, { color: "red", wrap: "wrap", children: error }) }))] }));
+});
+export default SoundsSelector;

package/dist/cli/ink-cli/components/overlays/ToolBrowser.d.ts

@@ -4,7 +4,7 @@
  * Features:
  * - Search/filter tools by name
  * - View tool details (description, schema)
- * - Shows source (MCP server or Internal)
+ * - Shows source (MCP server or Local)
  */
 import React from 'react';
 import type { Key } from '../../hooks/useInputOrchestrator.js';

package/dist/cli/ink-cli/components/overlays/ToolBrowser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ToolBrowser.d.ts","sourceRoot":"","sources":["../../../../../src/cli/ink-cli/components/overlays/ToolBrowser.tsx"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAON,MAAM,OAAO,CAAC;AAEf,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,qCAAqC,CAAC;AAC/D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAI9C,UAAU,gBAAgB;IACtB,SAAS,EAAE,OAAO,CAAC;IACnB,OAAO,EAAE,MAAM,IAAI,CAAC;IACpB,KAAK,EAAE,UAAU,CAAC;IAClB,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;CAC5B;AAED,MAAM,WAAW,iBAAiB;IAC9B,WAAW,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,GAAG,KAAK,OAAO,CAAC;CACrD;AAmBD;;GAEG;AACH,QAAA,MAAM,WAAW,4FAspBf,CAAC;AAyZH,eAAe,WAAW,CAAC"}
+{"version":3,"file":"ToolBrowser.d.ts","sourceRoot":"","sources":["../../../../../src/cli/ink-cli/components/overlays/ToolBrowser.tsx"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAON,MAAM,OAAO,CAAC;AAEf,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,qCAAqC,CAAC;AAC/D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAM9C,UAAU,gBAAgB;IACtB,SAAS,EAAE,OAAO,CAAC;IACnB,OAAO,EAAE,MAAM,IAAI,CAAC;IACpB,KAAK,EAAE,UAAU,CAAC;IAClB,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;CAC5B;AAED,MAAM,WAAW,iBAAiB;IAC9B,WAAW,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,GAAG,KAAK,OAAO,CAAC;CACrD;AAkBD;;GAEG;AACH,QAAA,MAAM,WAAW,4FA8rBf,CAAC;AAyZH,eAAe,WAAW,CAAC"}