mirror of
https://github.com/tinyhumansai/openhuman.git
synced 2026-07-29 22:23:01 +00:00
382038fcc8596afd6dcaf4ae94de5419f4a0548d
26
Commits
| Author | SHA1 | Message | Date | |
|---|---|---|---|---|
 Mega MindandGitHub
|
dc5e7adeb6 |
fix(auth): update RPC method names for authentication calls (#463)
* fix(auth): update RPC method names for authentication calls Refactor authentication-related RPC method names to use underscores instead of dots for consistency. Updated methods include `get_state`, `get_session_token`, `clear_session`, and `store_session`. chore: update OpenHuman version to 0.51.19 style: standardize string formatting in quickjs_libs/bootstrap.js and other files - Replace single quotes with double quotes for string literals in various functions. - Ensure consistent formatting across console logging and error handling. fix(config): improve token retrieval logic in ops_core.rs - Enhance the logic for retrieving the active session token from the credentials store, accommodating user-specific directories. * test: align auth and OAuth assertions with current behavior Update stale test expectations for underscore-style auth RPC methods and light-theme OAuth button classes, and make the bypass-login E2E assertion resilient to the current auth persistence model. Made-with: Cursor * chore: apply formatter output for login flow spec Include Prettier formatting adjustments produced by the pre-push hook so the branch can pass repository push checks cleanly. Made-with: Cursor |
||
|
Steven EnamakelandGitHub
|
4ee518cf31 |
feat(tree-summarizer): hierarchical summary tree module with CLI (#423)
* feat(tree-summarizer): implement hierarchical summarization engine and event handling - Introduced a new `tree_summarizer` module to manage hierarchical time-based summaries, organizing data into a tree structure (root → year → month → day → hour). - Added functionality to ingest raw content, summarize it into hour leaves, and propagate summaries upward through the tree. - Implemented event handling for summarization completion and tree rebuild events, enhancing observability and modularity. - Created RPC operations for ingesting content, triggering summarization, querying the tree, and retrieving tree status. - Added comprehensive tests to ensure the reliability of the summarization process and event handling. This update significantly enhances the summarization capabilities of the system, allowing for efficient data organization and retrieval. * feat(tree-summarizer): add CLI support for tree summarization commands - Introduced a new `tree-summarizer` command to the CLI, allowing users to ingest content, run summarization jobs, query the summary tree, check status, and rebuild the tree. - Updated the CLI help documentation to include the new command and its subcommands. - Added a new module `tree_summarizer_cli` to encapsulate the tree summarization functionality. This enhancement improves the usability of the summarization features, providing a streamlined interface for managing hierarchical summaries directly from the command line. * style: apply cargo fmt to tree_summarizer module * feat(tree-summarizer): implement TreeSummarizerEventSubscriber for observability logging - Added a new `TreeSummarizerEventSubscriber` to log events related to tree summarization, enhancing observability. - Updated the `start_channels` function to register the new subscriber. - Refactored the `run_summarization` function to group buffered entries by hour and publish events upon completion of summarization. - Improved documentation and added tests for the new subscriber functionality. This update aims to provide better insights into the summarization process and facilitate future cross-module workflows. * refactor(tree_summarizer): streamline buffer backup and function signature - Simplified the buffer backup process by consolidating the rename operation with context handling for better error reporting. - Cleaned up the function signature of `derive_node_ids_from_hour_id` for improved readability. These changes enhance code clarity and maintainability within the tree summarization engine. * feat(tree_summarizer): enhance tree summarization with metadata support - Updated the `tree_summarizer_ingest` function to accept an optional metadata parameter, allowing users to include additional context during content ingestion. - Refactored related functions to validate and handle metadata, improving the overall robustness of the summarization process. - Adjusted the buffer write functionality to store metadata alongside content, enhancing the data structure for future retrieval and processing. These changes aim to enrich the summarization capabilities and provide more context for ingested content. * refactor(tree_summarizer): improve error message formatting in node ID validation - Enhanced the formatting of error messages in the `validate_node_id` function for better readability and consistency. - Adjusted the string formatting to use multi-line syntax, improving clarity in error reporting. - Minor formatting changes in the `strip_buffer_frontmatter` function to enhance code readability. These changes aim to improve the maintainability and clarity of error handling within the tree summarization module. * refactor(tree_summarizer): enhance buffer management and summarization process - Replaced the buffer draining mechanism with a non-destructive read approach, allowing for safer data handling during summarization. - Introduced a new `buffer_delete` function to explicitly manage the deletion of buffer entries after successful processing. - Updated the `run_summarization` function to reflect these changes, ensuring that buffer entries are only deleted after durable writes are confirmed. - Improved the backup process for the buffer directory during tree rebuilds, ensuring it is preserved outside the tree structure. These modifications aim to improve data integrity and clarity in the summarization workflow. * refactor(tree_summarizer): improve markdown parsing and timestamp handling - Updated the `parse_node_markdown` function to trim trailing whitespace from the body after splitting frontmatter, enhancing data cleanliness. - Modified test cases to use specific timestamps instead of the current time, ensuring consistent and predictable test results. - Adjusted assertions in tests to reflect the new timestamp-based ordering of entries. These changes aim to improve the robustness of markdown parsing and the reliability of test outcomes in the tree summarization module. |
||
|
|
91996a1dd0 |
fix(voice): reduce dictation hallucinations and improve Fn/focus reliability (#385) (#409)
* fix(voice): add per-segment confidence validation in whisper engine (#385) Reject whisper segments with avg token log-probability below -0.7 or entropy above 2.4. Return TranscriptionResult with confidence metadata instead of plain String. Update callers in speech.rs and streaming.rs. Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com> * fix(voice): upgrade default STT model from tiny to base (#385) Base model produces significantly fewer hallucinations than tiny, especially in noisy/quiet conditions. User can still override via config. Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com> * fix(voice): add real-time silence gating in audio capture (#385) Gate sustained silence (>500ms) from being sent to whisper to prevent hallucinations. Maintain 100ms look-ahead ring buffer so speech onset after pauses is not clipped. Thresholds adapt to source sample rate. Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com> * fix(voice): fix Fn key timing race condition in hotkey event loop (#385) start_recording() blocks 1-7s on cpal device init but macOS fires Fn Release almost immediately, causing skipped cycles. Move recording start to spawn_blocking so the event loop stays responsive. Buffer Release events during setup and ensure minimum 1.5s recording duration when release arrives before recording handle is ready. Also includes: capture focused app on hotkey press, pass through pipeline for focus validation before paste. Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com> * fix(voice): validate and restore focus before paste, attempt regardless (#385) Add expected_app parameter to insert_text(). Before Cmd+V, validate focus via accessibility API and restore via AppleScript if shifted. Don't abort paste on focus validation failure — attempt insertion regardless so text is never silently lost. Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com> * fix(voice-ui): align voice server RPC response shape in settings panel (#385) * style(voice): apply rustfmt formatting in text_input * fix(voice): address CodeRabbit regressions in server, streaming, and settings polling --------- Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com> |
||
|
Steven Enamakel
|
6b1b2b9ba2 | update | ||
|
Steven Enamakel
|
cb0cec0c70 | fix | ||
|
Steven Enamakel
|
8bda914576 | ifix buils | ||
|
Steven EnamakelandGitHub
|
3851d1ef67 |
fix(voice): anti-hallucination, clipboard paste, Fn key reliability (#380)
* fix(dictation): update hotkey default value and documentation - Changed the default global hotkey for dictation from "CmdOrCtrl+Shift+D" to "Fn" in both the configuration schema and the associated documentation. - Updated the hotkey parsing function to recognize "Fn" as a valid key, enhancing the flexibility of hotkey configurations. - Added a test case to ensure the "Fn" key can be parsed correctly, improving the robustness of the hotkey handling functionality. * fix(voice): update default activation mode and hotkey in configuration - Changed the default activation mode for voice and dictation from "tap" to "push" in the respective configuration schemas. - Updated the default hotkey for voice commands from "ctrl+shift+space" to "Fn" across various modules and documentation. - Adjusted related tests to reflect the new defaults, ensuring consistency in behavior and expectations. * feat(voice): integrate embedded global voice server startup - Added a new asynchronous function `start_if_enabled` to the voice server module, which initializes the embedded voice server based on configuration settings. - Updated the server run logic to check if the voice server should auto-start, enhancing the startup process for the core application. - Integrated the new server startup function into the main server run logic, ensuring the voice server is launched if enabled in the configuration. * feat(voice): add VoicePanel for managing voice server settings - Introduced a new `VoicePanel` component to handle voice server configurations, including startup options, hotkeys, and runtime controls. - Updated routing in the settings page to include the new voice settings section. - Enhanced the `useSettingsNavigation` hook to support navigation to the voice settings. - Added tests for the `VoicePanel` to ensure functionality and reliability of the voice server management features. * refactor(dictation): update documentation and improve component initialization - Revised comments in `DictationHotkeyManager` to clarify the component's mounting process within the app tree. - Removed unused imports and unnecessary state management from `ServiceBlockingGate`, streamlining the component's logic. - Updated tests for `ServiceBlockingGate` to reflect changes in behavior, ensuring accurate rendering of child components based on service status. - Enhanced the `Cargo.lock` file by updating dependencies to their latest versions for improved stability and security. * fix(voice): update default skip_cleanup setting and enhance VoicePanel options - Changed the default value of `skip_cleanup` in the voice server configuration from `false` to `true` to improve transcription handling. - Reordered options in the `VoicePanel` component to ensure "Natural cleanup" is displayed alongside "Verbatim transcription" for better user clarity. - Updated tests to reflect the new default settings and ensure proper functionality of the VoicePanel component. * feat(window): add window management commands for Tauri application - Introduced a new module `window.ts` containing functions for managing window visibility and state in a Tauri application. - Implemented commands to show, hide, toggle visibility, minimize, maximize, close, and set the title of the main window. - Added checks to ensure commands are only executed in a Tauri environment, enhancing compatibility with web contexts. * feat(tauriCommands): add comprehensive Tauri command modules - Introduced multiple new modules for Tauri commands, including `accessibility`, `autocomplete`, `config`, `conscious`, `core`, `cron`, `hardware`, `localAi`, and `window`. - Each module contains functions for managing specific functionalities such as accessibility permissions, autocomplete suggestions, configuration settings, and hardware interactions. - Implemented checks to ensure commands are executed only in a Tauri environment, enhancing compatibility and reliability. - This addition significantly expands the command capabilities of the Tauri application, providing a robust framework for future development. * feat(voice): enhance audio transcription with initial prompt support - Added functionality to transcribe audio with an optional initial prompt, allowing for vocabulary bias and improved conversational continuity. - Updated the `transcribe_pcm_f32` and `transcribe_wav_file` functions to accept an `initial_prompt` parameter, enhancing recognition of specific vocabulary. - Implemented peak RMS energy tracking during audio recording for silence detection, ensuring recordings below a defined threshold are skipped. - Enhanced the voice server configuration to include a silence threshold and custom dictionary for better transcription context. - Introduced methods to build and manage recent transcripts for improved continuity across consecutive recordings. - Updated tests to validate new features and ensure proper functionality of the transcription process. * feat(voice): enhance VoiceServerConfig with silence detection and custom dictionary - Added `silence_threshold` to the `VoiceServerConfig` for improved silence detection, allowing recordings with low RMS energy to be skipped. - Introduced `custom_dictionary` to bias transcription towards specific vocabulary, enhancing recognition of names and technical terms. - Updated the `voice_transcribe` and `voice_transcribe_bytes` functions to utilize the new `initial_prompt` parameter for better context during transcription. - Adjusted the `transcribe_pcm_i16` function to accept additional parameters for improved flexibility in handling audio input. * feat(voice): add silence threshold and custom dictionary features to VoicePanel - Implemented a new input for setting the silence threshold, allowing recordings with low RMS energy to be skipped. - Added functionality for a custom dictionary, enabling users to add specific vocabulary words to improve transcription accuracy. - Updated the VoiceServerSettings interface and related functions to support the new features, ensuring seamless integration with existing settings. - Enhanced the UI in the VoicePanel to facilitate user interaction with the new settings. * feat(voice): propagate silence threshold and custom dictionary to voice server command - Added `silence_threshold` and `custom_dictionary` parameters to the `run_voice_server_command` function, ensuring these settings are utilized during voice server operations. - Enhanced integration with the existing voice server configuration to support improved transcription accuracy and silence detection. * fix(tauriCommands): update import paths for coreRpcClient - Adjusted import paths for `callCoreRpc` in multiple Tauri command modules to ensure correct referencing from the updated directory structure. - This change enhances module organization and maintains consistency across the codebase. * feat(dependencies): update Cargo.lock and Cargo.toml for new packages and versions - Added new dependencies including `arboard`, `fax`, `fax_derive`, `gethostname`, `half`, `quick-error`, `tiff`, and `x11rb` to enhance functionality and support for clipboard operations, transcription improvements, and system interactions. - Updated existing dependencies to their latest versions for better performance and compatibility. - Modified `VoicePanel` to utilize the updated settings and ensure proper handling of voice server configurations. - Enhanced the text input mechanism to use clipboard-paste for improved reliability in text insertion. * fix(voice): update skip_cleanup default value and enhance logging - Changed the default value of `skip_cleanup` in `VoiceServerConfig` from `true` to `false` to align with expected behavior and improve transcription handling. - Added detailed logging in the transcription cleanup process to provide better insights into the LLM state and cleanup decisions. - Removed unused functions related to unreliable key releases in hotkey handling to simplify the codebase. - Updated tests to reflect the new default settings for `skip_cleanup` and ensure proper functionality across components. * style: apply linter formatting fixes * fix(voice): remove unused warn import in hotkey module * test(voice): add silence threshold and custom dictionary to VoicePanel tests - Updated tests for the VoicePanel component to include new parameters: `silence_threshold` and `custom_dictionary`. - Ensured that the tests reflect the latest configuration settings for improved transcription accuracy and functionality. |
||
|
|
88257d3231 |
feat(update): core sidecar self-update with version detection (#372)
* update * update * Refactor code style for consistency and readability in core update module - Reformatted platform_triple function to improve readability by aligning braces. - Simplified async function calls and error handling in various places for better clarity. - Enhanced logging statements for improved observability during update processes. These changes enhance the maintainability of the codebase while ensuring consistent formatting across the module. * feat(update): periodic background update checker with config flag Add a periodic update scheduler that checks GitHub Releases for newer core binary versions on a configurable interval (default: 1 hour). Controlled by `[update]` config section with `enabled = true` by default. - New `UpdateConfig` in config schema (enabled, interval_minutes) - Env var overrides: OPENHUMAN_AUTO_UPDATE_ENABLED, OPENHUMAN_AUTO_UPDATE_INTERVAL_MINUTES - Background scheduler spawned at server startup in run_server() - Reports to health registry as "update_checker" component Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com> * fix(update): address PR review — restart path, security, version tracking - CoreProcessHandle: add set_core_bin/effective_core_bin so ensure_running launches the newly staged binary instead of the original one - check_and_update_core: add `force` param — auto-check uses MINIMUM_CORE_VERSION, manual apply_core_update uses latest release (force=true) - Acquire restart_lock before download+staging to prevent concurrent updates; shutdown old process before staging; use unique temp filename - check_core_update Tauri command now queries GitHub for latest_version and returns update_available alongside outdated - Harden update_apply RPC: validate download URL is GitHub HTTPS, validate asset_name is safe filename starting with openhuman-core-, ignore caller staging_dir (always use safe default) - download_and_stage accepts target_version so installed_version reflects the staged release, not the running process - Add update.check and update.apply to about_app capability catalog - ops.rs: unwrap_or_default → unwrap_or_else with error context - tauriCommands.ts: convert to arrow-function exports, add latest_version and update_available to CoreUpdateStatus interface Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com> * format --------- Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com> |
||
|
|
24b892439d |
feat(channels): Discord server/channel wiring and picker (#289) (#349)
* feat(channels): add channel_id to DiscordConfig schema Add optional channel_id field to DiscordConfig for restricting the bot to a specific Discord channel, matching the pattern used by SlackConfig and MattermostConfig. Refs: #289 Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com> * feat(channels): add channel_id field to Discord definition Expose channel_id as an optional field in the Discord BotToken auth mode so users can specify a default channel for outbound messages via the UI. Refs: #289 Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com> * feat(channels): create Discord API helper module for guild/channel discovery Refactor discord.rs into discord/ folder module and add api.rs with: - list_bot_guilds: GET /users/@me/guilds - list_guild_channels: GET /guilds/{id}/channels (filtered to text channels) - check_channel_permissions: compute bot permissions from roles + overwrites Includes unit tests for type serialization and permission bit constants. Refs: #289 Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com> * feat(channels): add Discord RPC handlers for guild/channel discovery Add three new RPC endpoints: - openhuman.channels_discord_list_guilds: list servers the bot is in - openhuman.channels_discord_list_channels: list text channels in a guild - openhuman.channels_discord_check_permissions: validate bot permissions These retrieve the stored Discord bot token from credentials and call the Discord REST API directly from the Rust core. Refs: #289 Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com> * feat(channels): wire channel_id into Discord provider for channel filtering Add channel_id field to DiscordChannel struct and update all construction sites. When channel_id is set, the listen loop only processes messages from that specific channel, enabling server+channel-scoped operation. Refs: #289 Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com> * feat(channels): add Discord guild/channel API types and RPC methods Add TypeScript types for DiscordGuild, DiscordTextChannel, and BotPermissionCheck. Wire up three new RPC methods in channelConnectionsApi for listing guilds, listing channels, and checking bot permissions. Refs: #289 Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com> * feat(channels): create DiscordServerChannelPicker component Add server and channel selection UI that loads guilds and channels from the Discord API via the Rust core RPC. Includes permission checking with visual feedback for missing permissions. Refs: #289 Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com> * feat(channels): integrate server/channel picker into DiscordConfig Show DiscordServerChannelPicker below the connect buttons when the bot_token connection is active. Guild and channel selections flow back into the credential field values for persistence. Refs: #289 Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com> * test(channels): add unit tests for Discord channel_id and config serde Add tests for: - DiscordConfig TOML/JSON deserialization with and without channel_id - channel_id field storage on DiscordChannel struct - Config roundtrip serialization Refs: #289 Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com> * test(channels): add Vitest tests for DiscordServerChannelPicker Test guild loading, rendering, and placeholder states with mocked RPC responses. Verifies the component renders heading, loads guilds from the mock, and shows the select placeholder. Refs: #289 Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com> * fix(ci): resolve discord module conflict and format drift * fix(reviews): address CodeRabbit Discord picker and permission issues --------- Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com> |
||
|
Steven EnamakelandGitHub
|
90f7a0dc54 |
feat(webhooks): add developer webhook debug panel (#314)
* feat(webhooks): add Webhooks Debug Panel and related functionality - Introduced a new Webhooks Debug Panel for inspecting registered webhook tunnels and viewing captured request/response logs. - Added necessary backend support for listing webhook registrations and logs, as well as clearing logs. - Updated Developer Options to include a route for the new Webhooks Debug Panel. - Enhanced core RPC client to support new webhook-related commands and events. - Implemented logging and error handling for webhook requests in the backend. This feature enhances developer tooling for monitoring and debugging webhook interactions. * feat(webhooks): add Webhooks Debug Panel and related functionality - Introduced a new Webhooks Debug Panel for inspecting registered webhook tunnels and captured request logs. - Added functionality to list webhook registrations and logs, clear logs, and display real-time updates. - Updated Developer Options to include the new Webhooks section. - Enhanced core RPC client to support new webhook-related commands and events. - Implemented backend support for webhook event handling and logging. This feature aims to improve developer tooling for monitoring and debugging webhook interactions. * feat(webhooks): enhance TunnelList and useWebhooks for echo registration - Updated TunnelList component to include functionality for registering and unregistering echo for tunnels. - Enhanced useWebhooks hook to support echo registration and unregistration, including real-time updates for tunnel activity. - Added connection status display in the Webhooks page to indicate the connection state to the core service. - Improved error handling and user feedback for echo toggle actions in the TunnelCard component. These changes improve the user experience for managing webhook tunnels and their associated echo registrations. * refactor(webhooks): streamline import of WebhookActivityEntry type - Removed redundant import statement for WebhookActivityEntry in useWebhooks.ts. - Updated the import to use a direct reference from the webhooksSlice, improving code clarity and maintainability. * ran formatter |
||
|
Cyrus GrayandGitHub
|
8b332c6735 |
fix(tauri): resolve "Command restart_core_process not found" stale ACL (#280)
* refactor(onboarding): remove MnemonicStep and Open Accessibility button, add Recovery Phrase settings panel
- Remove "Open Accessibility" button from ScreenPermissionsStep (step 2)
- Remove MnemonicStep (step 5) from onboarding, reducing total steps from 6 to 5
- Move onboarding completion logic (setOnboardedForUser + setOnboardingCompleted) into handleSkillsNext
- Add RecoveryPhrasePanel in Settings with the same BIP39 generate/import functionality
- Wire recovery-phrase route into Settings.tsx, SettingsHome menu, and useSettingsNavigation
* fix(recovery-phrase): add aria-labels to import inputs and word-count selector
Address CodeRabbit review feedback:
- Add aria-label to each recovery phrase word input for screen readers
- Add word-count selector (12/15/18/21/24) so longer phrases can be
entered manually, not just via paste
* fix(recovery-phrase): remove auto-advance on single char and guard clipboard fallback
Address CodeRabbit round 2:
- Remove auto-focus-advance after single character input (was breaking
manual word entry — typing 'abandon' would split across slots)
- Guard execCommand('copy') fallback with return value check
* fix(tauri): resolve "Command restart_core_process not found" by fixing stale ACL builds
Add cargo:rerun-if-changed directives for permissions/ and capabilities/
directories in build.rs so Tauri regenerates ACL tables on incremental
builds. Also add missing permission entries for dictation hotkey commands.
Closes #270
|
||
|
YellowSnnowmannandGitHub
|
8acd34d2a9 |
Feat/add dictation (#278)
* feat(dictation): implement voice dictation feature with overlay and settings panel - Added DictationOverlay component for real-time speech-to-text functionality, including recording, transcribing, and error handling. - Introduced useDictation hook to manage audio recording and transcription processes. - Created DictationPanel for configuring dictation settings, including hotkey registration and floating launcher preferences. - Updated SettingsHome to include a navigation option for the new dictation feature. - Integrated dictation state management with Redux, allowing for persistent settings and status checks. - Enhanced Tauri commands for registering global hotkeys and managing dictation state. This update provides a comprehensive voice dictation experience, enabling users to transcribe speech to text using local AI. * fix(dictation): update DictationOverlay to conditionally render based on floating launcher state - Reintroduced the useAppDispatch and useAppSelector hooks for state management. - Added showFloatingLauncher to the state selection, ensuring the overlay only renders when the floating launcher is active. - Simplified the return statement for position calculations in the drag handler. - Improved code readability by formatting JSX elements for better clarity. This update enhances the user experience by ensuring the dictation overlay behaves correctly based on the application's state. * feat(settings): add dictation route and panel to settings navigation - Updated the SettingsRoute type to include 'dictation' as a new route. - Integrated DictationPanel into the Settings page for user configuration. - Enhanced dictation state management by adding showFloatingLauncher to the dictationSlice, allowing for better control of the dictation overlay. This update improves the settings navigation and user experience by providing access to dictation features directly from the settings menu. * feat(dictation): integrate DictationOverlay and enhance dictation settings - Added DictationOverlay component to the main App for improved user interaction with dictation features. - Updated DictationPanel to include a new preference for showing a floating launcher, enhancing user control over dictation functionality. - Enhanced state management by incorporating showFloatingLauncher into the dictationSlice, allowing for better configuration of the dictation experience. This update improves the overall user experience by providing direct access to dictation features and customizable settings. * feat(dictation): enhance DictationOverlay and Conversations for improved text insertion - Added functionality to insert text into editable elements from the DictationOverlay, improving user interaction with dictation features. - Implemented event listener in Conversations to handle custom dictation insert events, allowing seamless integration of transcribed text into the input field. - Updated state management to ensure the correct editable target is used for text insertion, enhancing overall user experience. This update streamlines the dictation process, making it more intuitive and responsive to user actions. * fix(dictation): refine STT availability logic in dictationSlice - Updated the logic for determining STT availability to ensure it only considers the model file as available when both the model file exists and there is a method to run inference (either the in-process engine is loaded or a whisper binary is present). - This change prevents misleading user experiences by avoiding the display of the overlay when the necessary components for transcription are not available. This update enhances the reliability of the dictation feature by providing clearer conditions for STT availability. * refactor(dictation): streamline position management in DictationOverlay - Removed redundant state management for the position of the dictation overlay, consolidating logic to initialize and reset the position based on the current status. - Introduced a new `resetLauncherPosition` function to simplify resetting the overlay's position when necessary. - Updated event handling to ensure the overlay's position is reset appropriately after text insertion actions. This update enhances the clarity and efficiency of the DictationOverlay component, improving user experience during dictation interactions. * refactor(dictation): improve hotkey registration and unregistration process - Streamlined the logic for registering and unregistering dictation hotkeys, ensuring that old shortcuts are properly managed before new ones are registered. - Introduced rollback mechanisms to restore previous shortcuts in case of registration failures, enhancing reliability. - Simplified error handling and logging for better clarity during the hotkey management process. This update enhances the robustness of the dictation feature by ensuring a smoother transition between hotkey states. * refactor: delete unncessesary pr md file * refactor(dictation): enhance dictation functionality and error handling compatibility. * refactor(dictation): improve code formatting and readability across components - Enhanced formatting in DictationOverlay for better clarity in asynchronous action handling. - Streamlined text extraction logic in useDictation for improved readability. - Consolidated model directory setting in DictationPanel to a single line for simplicity. - Improved logging consistency in tauriCommands and speech service files. These changes enhance the maintainability and readability of the dictation-related components. * refactor(dictation): manage DictationOverlay position based on status changes - Introduced a reference to track the previous status of the dictation overlay. - Updated the effect to reset the overlay's position when transitioning from 'idle' to any other status, enhancing user experience during dictation sessions. This change improves the responsiveness of the DictationOverlay component to status changes, ensuring a smoother interaction for users. * refactor(tests): update MemoryWorkspace tests to specify span selector - Modified test assertions in MemoryWorkspace.test.tsx to include a selector for 'span' elements when checking for text presence. - This change enhances the specificity of the tests, ensuring they accurately target the intended elements in the rendered component. These updates improve the reliability of the MemoryWorkspace component tests. |
||
|
|
3c247a2439 |
Feat/humanlike replies (#168)
* fix(chat): prevent stacked socket listeners on reconnect subscribeChatEvents was declared async despite having no awaits, so the cleanup function was returned in a microtask after React's synchronous cleanup had already run. Each socket reconnect added another layer of listeners that were never removed, causing chat:done to fire N times and produce duplicate message bubbles. - Remove async keyword from subscribeChatEvents; return cleanup fn directly - Update useEffect call site to store cleanup synchronously and return it to React (eliminates the mounted/then race entirely) Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com> * feat(local-ai): add multi-turn chat via Ollama /api/chat Expose openhuman.local_ai_chat RPC method so the UI can run full conversation-history chat directly through the bundled Ollama model without touching the cloud inference API. - ollama_api.rs: add OllamaChatMessage / OllamaChatRequest / OllamaChatResponse types for the /api/chat endpoint - service/public_infer.rs: add LocalAiService::chat_with_history() — sends multi-turn message array to Ollama, updates latency/TPS status on response - ops.rs: add LocalAiChatMessage struct and local_ai_chat async op - schemas.rs: register local_ai_chat controller (schema, handler, params) in all_controller_schemas + all_registered_controllers Zero cloud tokens are consumed on this path; the call never reaches the backend socket or the /openai/v1/chat/completions endpoint. Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com> * feat(conversations): local-model chat gate with multi-bubble delivery When Ollama is ready (isLocalModelActive), handleSendMessage bypasses the cloud socket entirely and routes through openhumanLocalAiChat. Response is segmented and delivered as multiple typed bubbles with natural pauses — human-like reply behaviour at zero cloud token cost. UI / delivery - deliverLocalResponse(): segments full reply via segmentMessage(), dispatches each bubble with getSegmentDelay() pause between them; typing indicator (isDelivering) shows between segments - Socket-connected guard skipped on local path so offline local use works - Cloud socket path (chatSend → chat:done) fully unchanged Frontend RPC - tauriCommands: openhumanLocalAiChat(messages, maxTokens?) wraps openhuman.local_ai_chat via core RPC; LocalAiChatMessage type exported Tests (402 passing) - messageSegmentation: 4 new edge-case tests (whitespace, 80-char boundary, paragraph split, delay scaling) - localChatGating (new file): 9 tests — segmentation correctness, delay bounds [500, 1400] ms, sender→role mapping for message history build Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com> * fix(prompts): replace vague emoji guidance with explicit contextual rules The previous "Minimal — match the user's style" instruction was too loose, causing the model to stack decorative emojis on every message (e.g. "Hey! 😄 Just cooking up some AI magic! 🚀🔥✨"). SOUL.md — add Emoji Rules section: - Hard cap: one emoji maximum per message; none is always acceptable - Contextual, not decorative: emoji must reinforce the specific content (🔥 for exciting news, 🤔 for uncertainty, ✅ for confirmations) - Never open a sentence with an emoji - Skip entirely in error/warning/technical/long responses - Mirror the user's own emoji usage pattern - Concrete good/bad examples so the model can calibrate BOOTSTRAP.md — tighten the Communication Preferences entry to reference the same rules rather than the old vague one-liner. Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com> * chore: scope PR_DESCRIPTION.md to feat/humanlike-replies only Remove unrelated package manager distribution content (was from a different branch). Description now covers only the 4 commits on this branch: socket listener fix, Rust local_ai_chat RPC, frontend local chat gate + multi-bubble delivery, and emoji prompt rules. Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com> * refactor(local_ai): improve code formatting and readability in chat operations - Adjusted formatting in local_ai_chat function for better readability by adding line breaks. - Simplified the mapping of messages to OllamaChatMessage in ops.rs. - Streamlined the await syntax in schemas.rs for clarity. - Enhanced formatting in public_infer.rs for consistency in API request construction. * refactor(conversations): enhance code readability and structure in Conversations component - Improved formatting and consistency in the Conversations component, including better alignment of dispatch calls and message handling logic. - Removed redundant imports and streamlined the mapping of stored messages for clarity. - Adjusted conditional rendering for improved readability in the UI logic. --------- Co-authored-by: Claude Sonnet 4.6 <noreply@anthropic.com> |
||
|
cyrus@tinyhumans.ai
|
2570195604 |
feat(local-ai): add guided model tier selection by device capability
Add tiered model presets (Low/Medium/High) with device-aware recommendations so users can pick a local AI model that fits their machine without editing raw JSON config. Detect RAM, CPU, GPU via sysinfo crate and recommend a tier. Persist selection to config.toml, with env var override and graceful degradation hints on bootstrap failure. - Rust: presets.rs (tier definitions, recommendation logic), device.rs (hardware detection), 3 new RPC methods, env var override, bootstrap hints - Frontend: tier selector UI in Settings > Local AI Model with device info, loading/error states, and "Advanced" toggle for existing controls - Tests: 7 Rust unit tests + comprehensive JSON-RPC E2E test - Also fixes pre-existing lint warning in SkillSetupWizard.tsx Closes #80 |
||
|
Steven Enamakel
|
199303e110 |
refactor(release): enhance macOS app signing process
- Updated the signing workflow to sign non-main binaries (sidecars) before the main .app bundle, improving compliance with Apple notarization requirements. - Added diagnostic output to display the main executable name and list contents of the app bundle for better visibility during the signing process. - Improved comments for clarity on the new signing steps and their significance in the overall workflow. |
||
|
Steven Enamakel
|
dccd77c971 |
refactor(release): refine macOS app signing process
- Updated the re-signing workflow to focus on signing sidecar binaries and frameworks with hardened runtime, ensuring compliance with Apple notarization requirements. - Enhanced diagnostic output for better visibility during the signing process, including verification of sidecar binaries. - Improved comments for clarity on the signing steps and their significance in the overall workflow. - Bumped version to 0.49.30 in Cargo.lock to reflect changes. |
||
|
|
271394ade1 |
Fix/skills 3 (#103)
* refactor(skills): migrate to registry-based skill management and update state handling - Replaced Redux-based skill state management with hooks for improved performance, utilizing `useAvailableSkills`, `useSkillSnapshot`, and `useAllSkillSnapshots`. - Streamlined skill list derivation and sorting logic to enhance clarity and maintainability. - Updated components to reflect the new state management approach, ensuring real-time updates and compatibility with existing code. - Bumped OpenHuman version to 0.49.24 in Cargo.lock. * refactor(skills): update skill state handling and remove Redux dependencies - Simplified skill state management by replacing Redux-based logic with direct references to runtime maps. - Adjusted the SkillsGrid component to derive skill sync summary text without relying on skill states. - Removed unused Redux configurations and tests related to skills, streamlining the codebase. * fix(skills): make notifyOAuthComplete resilient when no local runtime notifyOAuthComplete and triggerSync no longer throw when the frontend SkillManager has no local runtime instance. They persist setup_complete via RPC first, then try core RPC pass-through as fallback. Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com> * refactor(skills): clean up imports and improve configuration handling - Consolidated import statements in the SkillsGrid component for better readability. - Updated the DEV_FORCE_ONBOARDING constant in the config file to enhance clarity and maintainability by combining conditions into a single line. * feat(skills): add SkillDebugModal for runtime skill inspection - Introduced SkillDebugModal component to inspect a skill's runtime state, including metadata, published state, and tool definitions. - Integrated the modal into the SkillCard component, allowing users to open it for debugging purposes. - Implemented functionality for calling tools and displaying results, enhancing the debugging experience for skills. * feat(skills): enhance OAuth deep link handling and skill management - Improved the OAuth deep link process by adding steps to persist setup completion, start the skill in the core runtime, and notify the skill of OAuth completion. - Enhanced error handling for starting skills and notifying OAuth completion, ensuring resilience in the skill management workflow. - Updated logging throughout the process to provide better insights into the state and actions taken during OAuth handling and tool calls. * chore(build): update Tauri configuration and add macOS build script - Disabled the creation of updater artifacts in the Tauri configuration to streamline the build process. - Introduced a new script for building and code-signing macOS Tauri releases, including notarization steps and environment variable validation. - Updated environment loading logic to source from the correct secrets file for improved configuration management. * feat(build): add pre-signing for sidecar binaries in macOS build script - Implemented pre-signing of sidecar binaries with hardened runtime and entitlements to comply with Apple notarization requirements. - Enhanced the build script to verify and sign all executables in the specified sidecar directory, ensuring proper code-signing before the build process. * feat(build): implement pre-signing for sidecar binaries in macOS build script - Added functionality to pre-sign sidecar binaries with hardened runtime and entitlements to meet Apple notarization requirements. - Enhanced the build script to verify and sign all executables in the specified sidecar directory, ensuring compliance before the build process. * feat(build): enhance macOS build process with notarization and sidecar re-signing - Added a new step to the release workflow for re-signing sidecar binaries with hardened runtime and notarization after the build process. - Updated the build script to remove pre-signing of sidecar binaries, ensuring notarization is handled separately for compliance with Apple requirements. - Improved the overall build process by verifying and re-signing all executables within the .app bundle, including frameworks and resources, before notarization. - Implemented DMG re-packaging after notarization to ensure the latest signed application is included in the distribution. * refactor(capture): consolidate import statements for AppContext and WindowBounds - Combined separate import statements for AppContext and WindowBounds into a single line for improved readability and organization in the capture module. * refactor(logging): improve log formatting for better readability - Updated log statements in various files to use multi-line formatting for improved clarity and consistency. - Enhanced the SkillDebugModal and event loop logging to streamline the output and make it easier to read. - Refactored log messages in js_handlers and ops_net to maintain uniformity in logging style. --------- Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com> |
||
|
|
777c98ef7c |
feat(skills): registry-based skill management + RPC state migration (#98)
* refactor(tauriCommands): streamline RPC method calls for skill management - Simplified the syntax of RPC method calls in the `tauriCommands.ts` file by removing unnecessary line breaks, enhancing code readability. - Updated descriptions in the `schemas.rs` file to maintain consistent formatting for RPC method descriptions, improving documentation clarity. * chore(release): bump OpenHuman version to 0.49.23 in Cargo.lock * feat(skills): add skill status management in desktopDeepLinkListener - Introduced a new action `setSkillStatus` to manage the skill's connection status. - Updated the OAuth deep link handling to dispatch the skill status as 'ready' upon successful connection, improving state management for skills. * feat(screen_intelligence): implement capture mode for screenshots - Added a `CaptureMode` enum to differentiate between windowed and fullscreen screenshot captures. - Enhanced the `capture_screen_image_ref_for_context` function to determine capture mode based on window bounds, with fallback to fullscreen. - Implemented logic to downscale screenshots exceeding size limits when captured in fullscreen mode. - Introduced a new `parse_foreground_output` function to parse application context from AppleScript output, improving context retrieval for screenshots. * chore(build): update Tauri configuration to remove updater artifacts creation - Modified the TAURI_CONFIG_OVERRIDE to exclude the creation of updater artifacts during the build process, streamlining the build workflow. * feat(accessibility): enhance accessibility state and add capture test functionality - Introduced new properties `captureTestResult` and `isCaptureTestRunning` to the `AccessibilityState` interface for managing capture test states. - Added `CaptureTestResult` and `CaptureTestContextInfo` interfaces to define the structure of capture test results. - Implemented `openhumanScreenIntelligenceCaptureTest` function to initiate screen intelligence capture tests, improving accessibility features. * feat(debug): add Screen Intelligence Debug Panel for enhanced diagnostics - Introduced a new `ScreenIntelligenceDebugPanel` component to display accessibility status, session information, and capture test results. - Integrated the debug panel into the existing `ScreenIntelligencePanel`, allowing users to expand and collapse the debug section. - Updated accessibility state management to include `captureTestResult` and `isCaptureTestRunning` for improved testing feedback. - Enhanced test setup to accommodate new debug functionalities. * feat(screen_intelligence): implement custom hook for screen intelligence items - Added `useScreenIntelligenceItems` hook to fetch and manage screen intelligence items from the accessibility state. - Integrated the hook into the `Intelligence` component, combining items from both memory and screen intelligence sources. - Enhanced loading state management to reflect the combined loading status of both data sources. * test(screen_intelligence): add unit tests for useScreenIntelligenceItems mapping and confidenceToPriority functions - Introduced tests for the mapping logic of AccessibilityVisionSummary to ActionableItem, ensuring correct transformation of properties. - Added tests for confidenceToPriority function to validate priority assignment based on confidence levels. - Included edge cases such as handling empty arrays, null app names, and long actionable notes truncation. * feat(mnemonic): update mnemonic handling to support variable word counts - Refactored mnemonic import logic to accommodate BIP39 phrase lengths (12, 15, 18, 21, 24 words). - Updated state initialization and validation to dynamically adjust based on the allowed word counts. - Enhanced user prompts to reflect the new word count options for recovery phrases. - Adjusted focus handling for input fields to improve user experience during phrase entry. * refactor(skills): migrate skill state management to RPC-based hooks - Replaced Redux-based skill state management with RPC-backed hooks for improved performance and reactivity. - Introduced `useSkillSnapshot` and `useAllSkillSnapshots` hooks to fetch skill states directly from the Rust core. - Updated components to utilize the new hooks, enhancing the overall architecture and reducing dependency on Redux. - Added event listeners to trigger state updates in response to skill state changes, ensuring real-time updates across the application. * fix(lint): merge duplicate tauriCommands import in accessibilitySlice test Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com> * refactor(tests): remove eslint-disable comment from screen intelligence E2E test file --------- Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com> |
||
|
Steven Enamakel
|
eacf7f1678 |
chore: update macOS sidecar signing process and add entitlements
- Introduced a new entitlements file for the sidecar to enhance security during code signing. - Updated the GitHub Actions workflow to utilize the entitlements file in the signing process. - Bumped OpenHuman version to 0.49.21 in Cargo.lock for dependency management. - Configured tauri.conf.json to reference the new entitlements file for macOS builds. |
||
|
Steven EnamakelandGitHub
|
14dc860a21 |
Skills runtime, onboarding, deep links, and core RPC refinements (#95)
* feat(telegram): implement Telegram channel and attachment handling - Added `TelegramChannel` struct for managing Telegram Bot API interactions, including user management and message handling. - Introduced attachment parsing with `TelegramAttachment` and `TelegramAttachmentKind` to support various media types. - Implemented functions for parsing attachment markers and validating URLs, enhancing message processing capabilities. - Created a new module structure for Telegram, including `attachments`, `channel`, and `text` for better organization and maintainability. * feat(skills): implement skills registry management and E2E testing - Added functionality for fetching, searching, installing, and uninstalling skills from a remote registry. - Introduced new modules for registry operations and types, enhancing the skills management system. - Implemented E2E tests for skills registry interactions, ensuring robust functionality and integration. - Updated documentation to reflect new skills registry features and usage instructions. * refactor(coreRpcClient): remove socket RPC handling and streamline HTTP request logging - Eliminated socket-based RPC handling to simplify the core RPC client logic. - Updated logging to use a unified debug logger for both HTTP requests and errors. - Improved error handling for HTTP responses to ensure clarity in error reporting. * feat(skills): enhance skill setup handling and improve error management - Updated SkillActionButton to directly open the setup modal for skills requiring OAuth, bypassing the QuickJS runtime. - Enhanced SkillSetupWizard to handle OAuth configuration more effectively, ensuring smoother transitions during skill setup. - Improved error handling during skill startup and setup processes, providing clearer logging for failures. - Refactored skills loading logic in the Skills page to prioritize registry-based skill fetching, with fallback to runtime discovery. - Added skill installation handling in the Skills page, allowing for better user feedback during installation processes. * feat(deep-link): enhance OAuth handling and streamline token management - Updated desktopDeepLinkListener to improve skill connection handling after OAuth completion. - Introduced setSkillSetupComplete action to mark skills as connected immediately post-OAuth. - Refactored token fetching logic to ensure encrypted tokens are stored correctly, enhancing error handling and reducing redundant checks. - Added new permissions in default.json for improved window management capabilities. * feat(skills): enhance skill management with global engine and runtime controllers - Added global engine management for skill runtime access, allowing RPC handlers to interact with the runtime engine. - Introduced new runtime controllers for skills, including start, stop, status, setup_start, list_tools, sync, and call_tool, enhancing skill lifecycle management. - Updated schemas to include new skill controller functionalities, improving the overall skills management system. - Enhanced documentation and comments for clarity on new features and usage. * refactor(skills): update global engine management and enhance documentation - Replaced OnceLock with RwLock for the global RuntimeEngine, allowing for better testability and flexibility in engine management. - Updated the global_engine and require_engine functions to return cloned Arc references, improving usability. - Enhanced documentation comments for clarity on the global engine's usage and behavior in production and testing scenarios. * chore(todos): update TODO list with removal of Tauri from Rust core - Added a new item to the TODO list indicating the need to remove Tauri from the OpenHuman Rust core, streamlining the project structure. * feat(onboarding): revamp onboarding steps and introduce local AI model consent - Replaced the PrivacyStep with a new ScreenPermissionsStep to handle accessibility permissions. - Added LocalAIStep for user consent on local AI model usage and download initiation. - Introduced SkillsStep and ToolsStep for selecting skills and enabling tools during onboarding. - Updated onboarding state management to include local model consent, download status, and enabled tools. - Enhanced the overall onboarding flow with new components and improved user experience. * feat(onboarding): enhance onboarding flow with new WelcomeStep and updated LocalAIStep - Introduced a new WelcomeStep to guide users through the onboarding process. - Updated LocalAIStep to clarify local AI model usage and consent, including improved messaging on privacy and resource impact. - Enhanced ScreenPermissionsStep to emphasize local processing of accessibility data. - Adjusted total steps in onboarding to reflect the addition of the WelcomeStep, improving user experience. * refactor(tray): remove tray integration and related functionalities - Deleted the tray module and its associated operations, streamlining the project structure. - Removed references to Tauri app handle in various components, transitioning to a memory client for skill data persistence. - Updated skill instances and event loops to eliminate dependencies on tray functionalities, enhancing modularity. - Improved documentation to reflect the removal of tray-related features and clarify the new architecture. * feat(onboarding): introduce OnboardingOverlay and enhance onboarding flow - Added OnboardingOverlay component to display the onboarding process as a full-screen overlay when the user is not onboarded. - Updated the Onboarding component to include a new MnemonicStep for recovery phrase management. - Enhanced onboarding state management to track workspace onboarding flags and user onboarding status. - Refactored AppRoutes to streamline routing and integrate the new onboarding flow. - Removed deprecated onboarding logic from previous steps, improving overall user experience. * refactor(sidebar): simplify hidden paths and update ProtectedRoute tests - Removed '/onboarding' from the hiddenPaths in MiniSidebar to streamline route visibility. - Updated ProtectedRoute tests to reflect changes in onboarding handling, ensuring children render correctly when authenticated. * chore: format, fix E2E lint, and onboarding step polish Made-with: Cursor * style(onboarding): update background color for onboarding steps - Changed background color from black/30 to stone-900 for improved visual consistency across LocalAIStep, MnemonicStep, ScreenPermissionsStep, SkillsStep, ToolsStep, and WelcomeStep components. - Enhanced overall aesthetics of the onboarding flow. * fix(tests): update variable naming and comment out unused JavaScript content - Renamed workspace variable to `_ws` to indicate it is unused in the `test_registry_cache_ttl_expired` test. - Commented out the `js_content` variable to prevent unused variable warnings in the test setup. * refactor(tests): streamline JSON-RPC test setup and remove unused backend URL handling - Updated the JSON-RPC end-to-end test to always use the in-process Axum mock for backend settings, ensuring consistent test behavior. - Removed the conditional logic for external backend URLs, simplifying the test setup. - Ensured proper cleanup of mock join handles after test execution. * refactor(runtime): update skill startup process to use core RPC - Replaced the direct call to `runtimeStartSkill` with a `callCoreRpc` method for starting skills, enhancing the integration with the core RPC system. - Updated comments to reflect the new implementation details. - Made minor adjustments to the schema organization in Rust for better clarity on runtime controllers. |
||
|
Steven EnamakelandGitHub
|
36fc5bdfa6 |
refactor(tauri): reduce desktop host to sidecar lifecycle + deep-link (#84)
* feat(onboarding): introduce DEV_FORCE_ONBOARDING flag to control onboarding flow - Added DEV_FORCE_ONBOARDING configuration to bypass onboarding checks during development. - Updated onboarding logic in AppRoutes to respect the new flag, ensuring onboarding is always shown when enabled. - Introduced new utility functions for managing onboarding state based on the flag. - Updated Cargo.lock and Cargo.toml to reflect dependency changes and version updates. - Removed deprecated openhuman command module and refactored related functionalities into daemon_host module for better organization. * feat(daemon): refactor daemon health monitoring and window management - Updated DaemonHealthService to use polling via `openhuman.health_snapshot` instead of event listening for health updates. - Introduced a new focusMainWindow function to centralize window focus logic across deep link handling and Tauri commands. - Replaced `invoke` calls with direct window management methods for showing, hiding, and toggling the main window. - Removed deprecated core_rpc module and related commands for improved organization and clarity. - Updated Cargo.toml and Cargo.lock to reflect dependency changes. * refactor(daemonHealthService): streamline imports and simplify tool object structure - Moved the import of `callCoreRpc` to a more appropriate location in DaemonHealthService. - Simplified the structure of the tools object in the aiGetConfig function for better readability. - Ensured consistency in Tauri command invocations by removing unnecessary line breaks. |
||
|
Steven Enamakel
|
591f29d7fb | Update OpenHuman package version to 0.49.19 in Cargo.lock | ||
|
Steven Enamakel
|
4dc4970f69 |
Enhance macOS build configurations and update version to 0.49.18
- Reinstated macOS ARM64 build configurations in the release workflow for improved compatibility. - Updated the version of the "OpenHuman" package in Cargo.lock to 0.49.18, ensuring consistency across the project. - Refactored search directory handling in core_process.rs for better clarity and maintainability, particularly for macOS platforms. - Added conditional compilation for macOS in various files to streamline platform-specific functionality. |
||
|
Steven Enamakel
|
5d865fa4e2 |
Update version to 0.49.17 across multiple files
- Bumped the version of the "openhuman" package in Cargo.lock and Cargo.toml to 0.49.17. - Updated the version in app/package.json and app/src-tauri/Cargo.toml to reflect the new release. - Adjusted the version in app/src-tauri/tauri.conf.json for consistency across the application. |
||
|
Steven EnamakelandGitHub
|
7ad3c73ac3 |
Refactor UI auth/bootstrap and remove legacy UI runtime layers (#63)
* Enhance E2E build process and backend URL handling - Updated `e2e-build.sh` to set CI environment variable correctly for compatibility with various CI runners. - Refactored `backendUrl.ts` to support dynamic backend URL resolution from Vite environment variables, improving flexibility in different deployment contexts. * Implement web channel functionality and enhance chat features - Introduced new web channel commands for sending and canceling chat messages, improving user interaction with the chat system. - Added support for server-sent events (SSE) to handle real-time updates for chat interactions, enhancing responsiveness. - Refactored existing code to improve readability and maintainability, including updates to the core HTTP router and JSON-RPC handling. - Implemented comprehensive end-to-end tests for the web channel flow, ensuring robust functionality and user experience. - Enhanced the overall structure of the web channel module, including event publishing and subscription mechanisms for better scalability. * Refactor socket handling to unify communication across environments - Removed Tauri-specific socket handling from various components, streamlining the codebase to use a single Socket.IO client for both web and desktop environments. - Updated the `useIntelligenceSocket` hook to eliminate Tauri checks and directly utilize the socket service for message sending and chat initialization. - Refactored metadata synchronization in Gmail and Notion services to use the unified socket service, enhancing consistency in socket communication. - Improved error handling and logging across socket interactions to provide clearer feedback during connection issues. - Enhanced the Conversations component to manage socket connection status, ensuring a more robust user experience during chat interactions. * Refactor socket service and enhance core URL resolution - Replaced the deprecated `getBackendUrl` function with `resolveCoreSocketBaseUrl` to improve backend URL resolution for socket connections, accommodating both Tauri and non-Tauri environments. - Introduced `coreSocketBaseFromRpcUrl` to streamline the processing of RPC URLs. - Removed the `tauriSocket.ts` file, consolidating socket handling into a unified service for better maintainability and clarity. - Updated the socket connection logging to provide more informative messages during connection attempts. * Add engineioxide and socketioxide packages to Cargo.lock and update Cargo.toml - Introduced new packages: `engineioxide` and `socketioxide`, both at version 0.15.2, enhancing the project's capabilities. - Updated `Cargo.toml` to include `socketioxide` with the "extensions" feature, ensuring proper integration with the existing codebase. - Added dependencies for both packages, improving modularity and functionality across the application. * Refactor Conversations component and streamline chat handling - Removed unused imports and functions related to Notion context and socket handling, simplifying the Conversations component. - Enhanced error handling during chat interactions, ensuring clearer feedback for users. - Updated chatSend function parameters to eliminate unnecessary context, improving the clarity of the API call. - Consolidated logic for managing chat message history and context, enhancing maintainability and readability of the code. * Enhance core RPC client with improved logging and error handling - Introduced debug logging for socket RPC requests and responses, providing better visibility into the communication process. - Enhanced error handling in the core RPC client to log detailed error messages, improving debugging capabilities. - Updated socket service to log inbound events, ensuring comprehensive tracking of socket interactions. - Removed deprecated MCP handlers from the socket service, streamlining the codebase and improving maintainability. * Refactor apiClient and socketService for improved maintainability - Changed the declaration of `_getToken` from `let` to `var` in `apiClient.ts` to enhance variable scoping. - Removed unused imports in `socketService.ts`, streamlining the code and improving readability. * Refactor deep link handling and enhance E2E testing capabilities - Updated the deep link configuration in `lib.rs` to use a more generalized `#[cfg(desktop)]` directive, improving compatibility across desktop platforms. - Enhanced the `triggerDeepLink` function in `deep-link-helpers.ts` to include macOS-specific app activation and launching logic, ensuring better integration with the macOS environment. - Introduced a new `buildBypassJwt` function to generate bypass JWT tokens for E2E testing, improving the flexibility of authentication flows in tests. - Updated E2E tests in `conversations-web-channel-flow.spec.ts` to utilize the new `triggerAuthDeepLinkBypass` function, enhancing the testing of authentication scenarios. * Enhance deep link handling and E2E test configuration - Updated `triggerAuthDeepLink` in `deep-link-helpers.ts` to support environment-based bypass tokens, improving flexibility in authentication flows during E2E tests. - Modified the `serve_on_ephemeral` function call in `json_rpc_e2e.rs` to disable the core HTTP router's default behavior, enhancing test isolation and control over the testing environment. * Refactor deep link handling and enhance E2E test utilities - Updated `authFlow.e2e.test.tsx` to utilize `window.__simulateDeepLink` for simulating deep links, improving test accuracy and alignment with real-world scenarios. - Modified `lib.rs` to restrict deep link registration to Windows and Linux platforms, clarifying platform-specific behavior. - Enhanced `deep-link-helpers.ts` with a new function to simulate deep links in the WebView, providing a fallback mechanism for E2E tests. - Updated `conversations-web-channel-flow.spec.ts` to reflect changes in deep link triggering, improving logging and test clarity. * Update dependencies in Cargo.lock and Cargo.toml for improved project stability - Removed several unused dependencies from `Cargo.lock` and `Cargo.toml`, including `aes-gcm`, `argon2`, and `async-imap`, streamlining the project and reducing potential security vulnerabilities. - Updated existing dependencies to their latest versions, ensuring compatibility and leveraging improvements in performance and security. - Simplified the dependency structure by consolidating features and removing unnecessary comments, enhancing clarity and maintainability of the configuration files. * Refactor App component and remove unused providers - Removed `AIProvider` and `SkillProvider` from the `App` component, streamlining the component structure and improving readability. - Updated the `UserProvider` to focus solely on bootstrapping the authentication token, enhancing its clarity and purpose. - Adjusted the layout within the `App` component to maintain functionality without the removed providers, ensuring a smooth user experience. * Remove deprecated AI components and types - Deleted the `index.ts`, `loader.ts`, `types.ts`, and related test files from the AI module, streamlining the codebase by removing unused and outdated components. - Eliminated the `default-constitution.md` and associated constitution files, which were no longer relevant to the current architecture. - This cleanup enhances maintainability and reduces complexity within the AI system. * Refactor user data fetching logic and remove legacy tools cache watcher - Enhanced the `useUser` hook to prevent infinite retry loops by implementing a token check with a reference to track the last auto-fetch token. - Removed the legacy file watcher for `TOOLS.md`, transitioning to a core RPC and socket event-based refresh mechanism for tool/config updates. - Updated test state structure to include `isAuthBootstrapComplete` and `channelConnections`, improving test coverage and state management. * Refactor channel module structure and add new providers - Consolidated channel modules under a new `providers` directory, improving organization and clarity. - Introduced new channel providers for DingTalk, Discord, Email, iMessage, IRC, and Lark, expanding the messaging capabilities of the application. - Updated the `mod.rs` file to reflect the new structure and ensure proper module exports, enhancing maintainability and ease of use. * refactor(ui): remove legacy providers/lib logic and stabilize auth bootstrap * chore: apply pre-push auto-fixes |
||
|
Steven EnamakelandGitHub
|
244702d349 |
Feat/refactor UI code (#52)
* Enhance autocomplete functionality and settings panel
- Added a new AutocompletePanel component for managing inline autocomplete settings, including options for enabling/disabling, debounce timing, and style configurations.
- Integrated autocomplete status tracking and logging within the panel to provide real-time feedback on the autocomplete engine's state.
- Updated settings navigation to include the new autocomplete settings route, improving user accessibility to autocomplete features.
- Introduced new Tauri commands for managing autocomplete operations, including start, stop, and current status retrieval, enhancing interaction with the autocomplete engine.
- Refactored existing code to streamline autocomplete-related functionalities and improve overall maintainability.
* Update TypeScript configuration and add new assets
- Modified `tsconfig.json` to adjust path aliases and include directories for improved module resolution.
- Added new SVG and image assets to the public directory, enhancing the application's visual resources.
- Introduced multiple Lottie animation JSON files for dynamic UI elements, expanding the application's animation capabilities.
* Update project structure and paths for Tauri integration
- Adjusted paths in the pull request template and various workflow files to reflect the new project structure, moving Tauri-related files under the `app` directory.
- Updated commands in the build and release workflows to ensure compatibility with the new file locations.
- Enhanced the test workflow to create the necessary `.env` file in the correct directory for end-to-end testing.
- Added new markdown files for agent prompts and configuration, establishing a foundation for OpenHuman's AI capabilities.
* Refactor project paths and update configurations for Tauri integration
- Adjusted script paths in package.json to reflect the new project structure, ensuring compatibility with the updated directory layout.
- Modified tsconfig.json to correct path aliases and include directories for improved module resolution.
- Introduced a new utility for resolving development paths, enhancing the ability to locate the `rust-core/ai` directory across different project structures.
- Updated Cargo.toml and tauri.conf.json to align with the new directory structure, ensuring proper resource and dependency management.
- Added a new dev_paths module to streamline path resolution logic, improving maintainability and clarity in the codebase.
* Refactor project structure and update configurations for Tauri integration
- Adjusted paths in .gitignore, Cargo.toml, and various scripts to reflect the new directory layout, moving Tauri-related files under the `app` directory.
- Introduced a new package.json file to manage workspace scripts and dependencies effectively.
- Updated end-to-end build and run scripts to ensure compatibility with the new project structure.
- Enhanced documentation in CONTRIBUTING.md to guide contributors on the updated project organization and Tauri command usage.
* Refactor Tauri command invocations to use dedicated utility functions
- Replaced direct `invoke` calls with utility functions from `tauriCommands` for improved readability and maintainability across multiple components.
- Updated `SkillsGrid`, `Skills`, `SkillProvider`, and `SkillManager` to utilize the new command structure, enhancing consistency in Tauri command handling.
- Introduced a new `coreRpcClient` for managing core RPC relay requests, streamlining error handling and request processing.
- Added a new `core_rpc_relay` command in the Tauri backend to facilitate communication with the core service, ensuring better service management and error reporting.
* Refactor Tauri command invocations in intelligence stats and memory manager
- Replaced direct `invoke` calls with utility functions from `tauriCommands` in `useIntelligenceStats` and `MemoryManager` for improved readability and maintainability.
- Updated the `aiListMemoryFiles`, `aiReadMemoryFile`, and `aiWriteMemoryFile` functions to utilize the new command structure, enhancing consistency in Tauri command handling.
- Introduced new command handling in the Rust backend for `ai.list_memory_files`, `ai.read_memory_file`, and `ai.write_memory_file`, streamlining communication with the core service.
* Refactor SkillsGrid and remove SelfEvolveModal component
- Removed the SelfEvolveModal component to streamline the SkillsGrid functionality.
- Updated the SkillsGrid to utilize the runtimeDiscoverSkills function for loading skills, replacing the previous invoke method.
- Simplified the skill entry normalization process by integrating it directly into the skills loading logic.
- Enhanced error handling during skill loading to improve robustness and user feedback.
* Refactor Tauri command invocations to use coreRpcClient
- Replaced direct `invoke` calls with `callCoreRpc` in various components, including `useIntelligenceStats`, `MemoryManager`, `SessionManager`, and `transcript` functions, enhancing code readability and maintainability.
- Updated the Rust backend to handle new command structures for memory and session management, streamlining communication with the core service.
- Improved consistency in handling Tauri commands across the application.
* Refactor Tauri command invocations to utilize coreRpcClient
- Replaced direct `invoke` calls with `callCoreRpc` in `tauriCommands.ts` and `tauriSocket.ts`, enhancing code readability and maintainability.
- Updated the Rust backend to support new command structures for authentication and session management, streamlining communication with the core service.
- Removed legacy socket reporting methods in `tauriSocket.ts`, reflecting a shift towards event-driven socket state management.
- Improved consistency in handling Tauri commands across the application, aligning with recent refactoring efforts.
* Remove pre-commit hook and update TODO list with completed tasks and new objectives. This includes separating the binary from the Tauri codebase, integrating accessibility service installation, and removing Android/iOS support from the codebase.
* Add core server functionality with dispatch and RPC handling
- Introduced new modules for core server operations, including dispatching RPC requests and handling various AI and memory-related commands.
- Implemented a robust structure for managing authentication, configuration, and session states through the `openhuman` namespace.
- Added helper functions for loading configurations, managing memory files, and processing authentication profiles.
- Established a new routing system using Axum for handling HTTP requests, including health checks and RPC endpoints.
- Enhanced error handling and logging throughout the new functionalities to improve maintainability and user feedback.
* Implement core server CLI and modular structure
- Introduced a new CLI module for the core server, enabling various commands for server management, health checks, and configuration settings.
- Established a modular structure for core server functionalities, including dispatching RPC requests and managing settings for models, memory, and runtime.
- Added comprehensive tests to validate the functionality of accessibility and autocomplete commands, ensuring robust error handling and schema compliance.
- Enhanced the overall organization of the core server codebase, improving maintainability and readability.
* Implement AI RPC dispatch functionality
- Introduced a new `ai_rpc` module for handling various AI-related commands, including memory file operations and session management.
- Enhanced the `try_dispatch` function to support commands such as listing, reading, writing memory files, and managing session states.
- Updated the core server dispatch module to integrate the new AI RPC functionality, improving modularity and maintainability.
- Refactored existing code to ensure consistent parameter parsing and error handling across AI commands.
* Update TODO list and refactor Rust core server files
- Added new tasks to the TODO list for documentation updates and feature flag cleanup.
- Introduced `Arc` import in `cli.rs` for improved concurrency handling.
- Cleaned up imports in `helpers.rs` and added conditional compilation for `tauri-host`.
- Removed unused `value_only` function in `types.rs` and added `#[allow(dead_code)]` to `SocketConnectParams` and `SocketEmitParams`.
- Enhanced `try_dispatch` function in `dispatch/mod.rs` for non-tauri-host scenarios.
- Updated `try_dispatch` in `openhuman/platform.rs` to correctly handle session parameters.
- Modified `screen_intelligence` configuration in tests to include new properties for better session management.
* Refactor import statements and enhance code readability
- Cleaned up import statements across multiple files for improved organization and consistency.
- Reformatted code in `cli.rs`, `helpers.rs`, and various dispatch modules to enhance readability.
- Ensured consistent parameter handling in `try_dispatch` functions, improving maintainability.
- Removed unnecessary whitespace and adjusted formatting for better code clarity.
* Refactor project structure and enhance AI memory management
- Consolidated the `openhuman-core` package into a single `Cargo.toml` file, removing the previous `rust-core` directory.
- Introduced new modules for AI memory management, including filesystem-based storage and encryption functionalities.
- Added Tauri commands for initializing memory and session management, enhancing user interaction with memory files.
- Implemented JSON-based storage for memory chunks and session transcripts, improving data accessibility and organization.
- Updated dependencies and features in `Cargo.toml` to support new functionalities and ensure compatibility.
* Update build and release workflows to reflect project structure changes
- Adjusted paths in GitHub Actions workflows to accommodate the consolidation of the `openhuman-core` package into a single `Cargo.toml`.
- Updated import statements in various files to point to the new locations of markdown resources.
- Modified the Tauri configuration to reflect the new resource paths, ensuring proper access to AI prompts.
- Enhanced the staging script to build the standalone binary from the updated project structure.
* Refactor AI directory resolution and update documentation
- Updated the logic for resolving AI directory paths to reflect the new project structure, replacing references to `rust-core/ai` with `src/ai/prompts`.
- Enhanced the `find_ai_directory` function across multiple modules to utilize the new path resolution methods.
- Updated documentation comments to clarify the new directory structure and fallback mechanisms for loading AI prompts.
* Rename `openhuman-core` to `openhuman` across the project
- Updated package names in `Cargo.toml` and `Cargo.lock` to reflect the new naming convention.
- Adjusted references in GitHub Actions workflows and scripts to use the new package name.
- Modified CLI command names and error messages to align with the updated naming.
- Ensured consistency in executable file names and paths throughout the codebase.
* Refactor project commands and update package scripts
- Updated package.json to change workspace references from `openhuman` to `app` for build, compile, dev, format, lint, and test scripts.
- Removed outdated memory and chat command files to streamline the codebase and improve maintainability.
- Adjusted the `lib.rs` file to reflect changes in memory command handling, transitioning to use `callCoreRpc` for Neocortex memory operations.
- Cleaned up the commands module by removing unused imports and consolidating functionality.
* Add Tauri host support and new daemon configuration
- Introduced new modules for Tauri host functionality, including `desktop` and `daemon_host`.
- Added static variables and initialization functions for managing the desktop app handle and resource directory.
- Updated import paths for `HeartbeatEngine` to improve clarity and organization.
- Implemented configuration loading and saving for daemon UI preferences, enhancing user experience.
* Update package names in project configuration
- Changed workspace references in package.json from `app` to `openhuman-app` for consistency.
- Updated the name field in the app's package.json to reflect the new naming convention.
* Remove Tauri host feature flags from core server modules
- Eliminated conditional compilation for Tauri host in `lib.rs`, `helpers.rs`, and `dispatch` modules.
- Streamlined socket management functions and dispatch logic by removing unused code related to Tauri host.
- Improved code clarity and maintainability by consolidating socket-related functionality.
* Enhance Tauri host feature integration and update dependencies
- Added `tauri-host` as a default feature in `Cargo.toml` to streamline feature management.
- Removed explicit feature flag from `openhuman` dependency in `app/src-tauri/Cargo.toml` for cleaner configuration.
- Updated Tauri command attributes in various modules to conditionally compile with the `tauri-host` feature, improving modularity.
- Expanded TODO list to include migration support from OpenClaw, indicating future development focus.
* Refactor authentication and credential management in OpenHuman
- Introduced new modules for handling authentication profiles and tokens, including `anthropic_token`, `openai_oauth`, and `profiles`.
- Removed unused Tauri host-related code from core server modules, enhancing clarity and maintainability.
- Updated `Cargo.toml` and `Cargo.lock` to reflect the removal of the `rquickjs` dependency and other package adjustments.
- Streamlined memory client initialization in dispatch logic to utilize the new `local_memory` module.
- Enhanced code organization by consolidating credential management functionalities and improving the overall structure of the OpenHuman module.
* Enhance Rust core RPC structure and streamline helper functions
- Introduced a dedicated `rpc.rs` file for each domain in the Rust core to manage JSON-RPC and CLI behavior, improving code organization and clarity.
- Refactored helper functions to utilize `rpc_invocation_from_outcome` for consistent handling of RPC responses across various modules.
- Removed unused authentication and credential management functions from `helpers.rs`, consolidating relevant logic into the new RPC structure.
- Updated dispatch logic in multiple modules to leverage the new RPC functions, enhancing maintainability and reducing code duplication.
* Enhance Rust core RPC structure and streamline helper functions
- Introduced a dedicated `rpc.rs` file for each domain in the Rust core to manage JSON-RPC and CLI behavior, improving code organization and clarity.
- Refactored helper functions to utilize `rpc_invocation_from_outcome` for consistent handling of RPC responses across various modules.
- Removed unused authentication and credential management functions from `helpers.rs`, consolidating relevant logic into the new RPC structure.
- Updated dispatch logic in multiple modules to leverage the new RPC functions, enhancing maintainability and reducing code duplication.
* Refactor OpenHuman configuration loading and enhance onboarding RPC
- Replaced the `load_openhuman_config` function with a new `load_config_with_timeout` method to improve timeout handling during configuration loading.
- Consolidated configuration loading logic across various modules, reducing redundancy and enhancing maintainability.
- Introduced new RPC functions for applying settings related to models, memory, screen intelligence, gateway, tunnel, runtime, and browser, streamlining the update process.
- Added onboarding helpers in a new `onboard` module, including a JSON-RPC controller for model refresh operations, improving onboarding flow management.
* Refactor CLI and configuration management in OpenHuman
- Consolidated CLI-related functionality by introducing new modules for settings and credentials management, enhancing code organization.
- Removed redundant functions and streamlined the configuration loading process, improving maintainability.
- Added new CLI helpers for screenshot tools and workspace initialization, facilitating better user experience and onboarding.
- Enhanced JSON-RPC responses to be more compatible with CLI requirements, ensuring consistent output across various commands.
* Remove gateway settings and related functionality from OpenHuman
- Eliminated the GatewaySettingsUpdate interface and associated functions from the codebase, streamlining configuration management.
- Removed references to gateway settings in the CLI and configuration modules, enhancing clarity and maintainability.
- Deleted the gateway module and its related components, including rate limiting and client handling, to simplify the architecture.
- Updated Cargo.toml and Cargo.lock to reflect the removal of dependencies related to gateway functionality.
* Update documentation and improve clarity in OpenHuman
- Revised comments in the `mod.rs`, `traits.rs`, and `pairing.rs` files to enhance clarity and accuracy.
- Updated descriptions related to security policy, long-running processes, and pairing functionality for better understanding.
* Refactor loading prop in TauriCommandsPanel for cleaner code
- Simplified the loading prop assignment in the TauriCommandsPanel component by removing unnecessary line breaks, enhancing readability and maintainability.
* Add OpenSSL dependency and implement OAuth authentication features
- Added OpenSSL as a dependency in `Cargo.toml` to support cryptographic operations.
- Introduced new OAuth-related structures and parameters in `types.rs` for handling authentication flows.
- Implemented OAuth connection and integration token fetching in `auth_socket.rs`, enhancing the authentication capabilities of the OpenHuman module.
- Created new modules for managing authentication profiles and responses, improving the organization of authentication-related code.
- Removed deprecated `anthropic_token` and `openai_oauth` modules to streamline credential management.
- Updated `Cargo.lock` to reflect the addition of the OpenSSL dependency.
* Refactor OpenHuman module and update dependencies
- Added OpenHuman integration entry in the registry for improved backend inference handling.
- Updated various files to enhance code clarity and organization, including adjustments to OAuth client methods and integration tests.
- Refactored import statements and removed unnecessary line breaks for better readability.
- Updated `Cargo.lock` to reflect changes in dependencies and ensure consistency across the project.
* Implement desktop host features and refactor runtime handling
- Introduced new modules for memory management, socket handling, and command definitions to support desktop host functionality.
- Refactored QuickJS runtime initialization to log errors when the engine is not linked, improving clarity on runtime status.
- Added placeholder commands for chat and model interactions, indicating unavailability in the desktop build while maintaining structure for future integration.
- Enhanced organization of the codebase by creating dedicated files for runtime and utility functions, streamlining the development process.
- Updated documentation to reflect new modules and their purposes, ensuring better understanding for future contributors.
* Add CLI banner and print function to enhance user experience
- Introduced a new CLI banner with branding and GitHub link for user engagement.
- Implemented a `print_cli_banner` function to display the banner when running the CLI, improving visibility and user interaction.
- Updated the CLI entry point to call the new banner function, ensuring it appears at startup.
* Add API integration and update dependencies
- Introduced new API modules for handling HTTP requests and WebSocket connections to the TinyHumans backend.
- Added `ureq` dependency for simplified HTTP client functionality, updating `Cargo.toml` and `Cargo.lock` accordingly.
- Implemented configuration and JWT handling in the new `api` module, enhancing session management and API interactions.
- Refactored existing code to utilize the new API helpers, improving code organization and maintainability.
- Updated documentation to reflect new API functionalities and usage guidelines.
* Refactor settings fetching and update dependencies
- Removed the `ureq` dependency and associated functions for fetching settings, streamlining the codebase.
- Updated the `fetch_settings` method to utilize `reqwest` for HTTP requests, enhancing consistency and reliability in API interactions.
- Adjusted the `Cargo.toml` to reflect the removal of `ureq`, ensuring dependencies are up to date.
* Update `ureq` dependency to version 3.3.0 in `Cargo.lock`
- Removed the specific version constraint for `ureq`, allowing for more flexibility in dependency resolution.
- Updated the `Cargo.lock` to reflect the new version of `ureq`, ensuring compatibility with recent changes in the codebase.
* Enhance JSON-RPC logging and CLI initialization
- Introduced a new `rpc_log` module for structured logging of JSON-RPC requests and responses, including redaction of sensitive parameters.
- Updated `execute_core_cli` to initialize logging with a default level and timestamp format.
- Enhanced logging in `rpc_handler` and `dispatch` functions to provide detailed insights into method calls and their execution times.
- Improved error handling logging to capture method failures with context, aiding in debugging and monitoring.
* Refactor HTTP server setup and add integration tests
- Introduced a new `build_core_http_router` function to encapsulate the HTTP routing logic, improving code organization and readability.
- Updated the `run_server` function to utilize the new router function, streamlining server initialization.
- Added comprehensive integration tests for the JSON-RPC API, ensuring robust functionality and error handling in real-world scenarios.
* Enhance OpenHuman backend integration and refactor provider handling
- Added support for the OpenHuman backend in the TauriCommandsPanel, including default configurations and validation for API keys.
- Introduced a new REPL command in the CLI for interactive RPC communication, allowing for dynamic mode switching and message handling.
- Refactored provider creation logic to streamline the integration of the OpenHuman backend, removing deprecated provider overrides and ensuring consistent usage across the codebase.
- Updated various components to improve error handling and user feedback related to provider selection and API interactions.
* Refactor provider handling and update default model settings
- Removed provider override states from the AgentChatPanel and TauriCommandsPanel components, simplifying state management.
- Updated local storage handling to exclude provider overrides, ensuring cleaner data storage.
- Changed default model settings across various components and backend configurations to use "neocortex-mk1" as the new default model.
- Enhanced error handling and validation logic in the TauriCommandsPanel, focusing on model and temperature settings.
- Streamlined integration tests and removed deprecated provider validation logic to improve code clarity and maintainability.
* Refactor code for improved readability and consistency
- Adjusted formatting in several files to enhance code clarity, including consistent parameter passing and alignment.
- Simplified match statement syntax in the `run_models` function for better readability.
- Streamlined assertions in tests to maintain consistency in error handling checks.
- Updated default model name handling in the `AgentBuilder` for cleaner initialization.
* Refactor API URL handling and enhance error reporting
- Updated the `effective_api_url` function to improve clarity in resolving the API base URL, incorporating environment variable checks.
- Enhanced diagnostics in the configuration check to provide clearer messages regarding the API URL status.
- Introduced new error formatting functions to improve the clarity of error messages related to API transport issues.
- Refactored error handling in the OpenAiCompatibleProvider to utilize the new error formatting, ensuring consistent and informative error reporting.
* Refactor API client initialization for consistency
- Updated the instantiation of `BackendOAuthClient` to consistently pass the API URL by reference across multiple functions.
- Simplified the match statement in the `run_models_refresh` function for improved readability.
* Enhance REPL command handling and add fallback mechanisms
- Improved error handling in the REPL command processing, providing clearer feedback for command execution failures.
- Introduced a fallback mechanism for the `agent_chat` RPC call, allowing for graceful degradation to a simpler chat method or a direct backend curl transport if the primary call fails.
- Added a new `backend_chat_via_curl` function to handle chat requests using curl as a last resort, ensuring continued functionality in case of RPC issues.
- Updated the `agent_chat_simple` function to support model overrides and temperature settings, enhancing flexibility in chat interactions.
* Update default Ollama model settings for consistency
- Changed the default Ollama model and vision model to "gemma3:4b-it-qat" for improved alignment across configurations.
- Ensured consistent model naming to enhance clarity in model usage within the local AI module.
* Implement login token consumption and enhance error handling
- Added functionality to consume login tokens via a new API endpoint, returning a JWT for authenticated sessions.
- Improved error handling in the Conversations component, introducing a fallback mechanism for chat interactions when the primary method is unavailable.
- Updated UserProvider to restore session tokens automatically, enhancing user experience during authentication.
- Refactored thread API to support the new login token consumption logic, ensuring seamless integration with the backend.
* Update HTTP client configuration to use Rustls TLS
- Replaced the HTTP/1.1 only setting with Rustls TLS in the OpenAiCompatibleProvider's client builder for enhanced security.
- Ensured consistent application of the new TLS setting across multiple client instances.
* Add Local AI command support and enhance error handling
- Introduced a new `LocalAi` command in the CLI for managing local AI runtime operations, including status checks, asset downloads, and prompt handling.
- Added detailed argument structures for various local AI functionalities, improving command usability.
- Enhanced error reporting in the `LocalAiService` by including response details in error messages for better debugging and user feedback.
- Refactored existing error handling to provide clearer context on failures during API interactions.
* Add local AI module with Ollama integration and model management
- Introduced a new local AI module that includes functionality for automatic installation of the Ollama runtime across different operating systems (Windows, macOS, Linux).
- Implemented model ID resolution and management, providing default settings for various AI models and ensuring compatibility with user configurations.
- Added HTTP API structures and request handling for Ollama, enabling interaction with the local AI service for generating responses and managing assets.
- Developed utility functions for parsing model outputs and managing workspace paths, enhancing the overall structure and usability of the local AI service.
- Established a comprehensive service layer for managing local AI operations, including status tracking and error handling for improved user experience.
* Refactor local AI service structure and enhance asset management
- Simplified the local AI module by reorganizing the service structure, introducing new modules for model IDs, paths, and asset management.
- Added comprehensive asset status tracking for various AI models, including chat, vision, embedding, STT, and TTS, with improved error handling.
- Implemented methods for downloading models and assets, ensuring better management of local AI resources.
- Updated visibility of service methods to enhance encapsulation and maintainability within the local AI service.
* Enhance local AI module with new download progress tracking and unit tests
- Added new structures for tracking download progress of various AI models, including detailed status and metrics.
- Implemented unit tests for model ID resolution, parsing suggestions, and asset path resolution to ensure robust functionality.
- Refactored service methods to improve encapsulation and maintainability, enhancing the overall structure of the local AI service.
- Updated existing tests to cover new functionalities and ensure consistent behavior across the module.
* Implement new local AI download functionalities and refactor model management
- Added support for downloading all local AI assets and tracking download progress, enhancing user experience and resource management.
- Introduced new RPC methods for fetching download progress and managing asset states, improving the overall functionality of the local AI module.
- Refactored existing model management code to utilize the new model catalog, ensuring better organization and maintainability.
- Updated relevant tests to cover new functionalities and ensure consistent behavior across the local AI service.
* Add new interfaces and functions for local AI download progress tracking
- Introduced `LocalAiDownloadProgressItem` and `LocalAiDownloadsProgress` interfaces to structure download progress data for various AI models.
- Implemented `openhumanLocalAiDownloadAllAssets` and `openhumanLocalAiDownloadsProgress` functions to facilitate downloading all assets and tracking their progress.
- Enhanced error handling for Tauri environment checks in new functions, ensuring robust operation within the local AI module.
* Refactor agent loop structure and introduce modular components
- Deleted the `loop_.rs` file and reorganized the agent loop into multiple modules for better maintainability and clarity.
- Introduced new files for handling credentials, history management, tool instructions, memory context, and parsing logic.
- Implemented functions for scrubbing sensitive credentials, managing conversation history, and building tool instructions.
- Enhanced the overall structure of the agent loop to facilitate easier testing and future development.
* Refactor authentication structure and migrate to credentials module
- Moved authentication-related functionality from `auth_profiles` to a new `credentials` module for better organization and clarity.
- Updated references in the API and core server to reflect the new module structure.
- Introduced new data structures and methods for managing authentication profiles, including session support and response handling.
- Removed the obsolete `auth_profiles` module to streamline the codebase and enhance maintainability.
* Add screen intelligence module with capture and context management
- Introduced new modules for screen capture and context management, specifically targeting macOS.
- Implemented functionality to capture screen images and retrieve foreground application context.
- Added data structures for managing application context and window bounds.
- Established limits for screenshot sizes and context character counts to ensure efficient resource management.
- Enhanced helper functions for input action validation and vision summary processing.
- Set up a modular structure for better maintainability and future enhancements.
* Refactor screen intelligence module and remove obsolete components
- Deleted unused files related to screen intelligence, including context and permissions management, to streamline the codebase.
- Refactored the capture functionality to improve organization and maintainability.
- Updated function signatures for better clarity and consistency.
- Enhanced the overall structure of the screen intelligence module for future development and testing.
* Enhance autocomplete CLI functionality and refactor related code
- Added new options for the autocomplete command in the CLI, allowing users to run the autocomplete loop in the current process or spawn a detached process.
- Introduced `AutocompleteStartCliOptions` struct to encapsulate the new command-line arguments.
- Refactored the `autocomplete_start_cli` function to handle the new options and improve process management for the autocomplete service.
- Updated documentation in `CLAUDE.md` to clarify the separation of concerns between routing and controller logic in the codebase.
* Enhance autocomplete error handling and improve focused text context retrieval
- Added a new function to identify "no text candidate" errors, improving error management in the autocomplete engine.
- Refactored the `focused_text_context` and `focused_text_context_verbose` functions to enhance clarity and reliability in retrieving application context.
- Updated the return format of the `focused_text_context_verbose` function to use a separator for better data parsing.
- Added a new TODO item for allowing users to select LLM model versions based on their CPU capabilities.
* Remove Docker, Native, and WASM runtime implementations along with related traits and tests
- Deleted the DockerRuntime, NativeRuntime, and WasmRuntime implementations to streamline the codebase.
- Removed associated traits and factory functions for runtime creation.
- Eliminated all related tests to ensure a clean removal of unused components.
- This refactor aims to simplify the runtime management and prepare for future enhancements.
* Add quickjs-runtime feature and introduce runtime module
- Added a new feature flag for `quickjs-runtime` in `Cargo.toml` to enable its usage.
- Created a new `runtime.rs` module to implement `NativeRuntime` and `DockerRuntime` with associated traits for runtime management.
- Updated the `skills` module to reference the correct path for `SkillConfig`.
- Removed the obsolete `skillforge` module from the `openhuman` namespace to streamline the codebase.
- Enhanced the `skills` module with new structures and functions for managing skills, including initialization and loading logic.
* Refactor autocomplete configuration to remove legacy disabled apps
- Updated the default configuration for `AutocompleteConfig` to remove the legacy disabled apps ('terminal' and 'code'), allowing for broader usage of Codex/CLI.
- Introduced a migration function to handle legacy disabled apps during configuration loading, ensuring custom user preferences remain intact.
- This change enhances the flexibility of the autocomplete feature by preventing unnecessary restrictions on application usage.
* Update rquickjs dependencies in Cargo.lock
- Updated the rquickjs and rquickjs-core dependencies to versions 0.11.0 and 0.9.0 respectively, ensuring compatibility with the latest features and fixes.
- Added new entries for rquickjs-sys and its corresponding version 0.9.0 to the dependency list, enhancing the project's runtime capabilities.
- This update improves the overall stability and performance of the application by leveraging the latest improvements in the rquickjs ecosystem.
* Add terminal application detection to autocomplete logic
- Introduced a new function `is_terminal_app` to identify terminal applications based on their names, enhancing the autocomplete feature's context awareness.
- Updated the `focused_text_context_verbose` function to allow terminal applications to bypass text role checks when the input value is not empty, improving user experience in terminal environments.
- This change aims to provide better support for terminal-based applications in the autocomplete system.
* Add terminal input context extraction and noise line detection
- Introduced functions to identify terminal-like buffers and filter out noise lines in terminal input, enhancing the autocomplete engine's context awareness.
- Updated the `focused_text_context` logic to utilize the new terminal context extraction, improving the handling of text in terminal applications.
- Enhanced the `focused_text_context_verbose` function to better retrieve static text values from UI elements, ensuring accurate context representation in terminal environments.
- These changes aim to improve user experience and functionality for terminal-based applications in the autocomplete system.
* Enhance autocomplete engine state management and error handling
- Added new fields `last_escape_down` and `last_overlay_signature` to `EngineState` for improved state tracking.
- Implemented `try_reject_via_escape` method to handle escape key interactions, allowing users to reject suggestions more intuitively.
- Updated error handling to display notifications for different states (ready, accepted, rejected, error) using `show_overflow_badge`.
- Refactored state updates to ensure consistent management of suggestion and phase transitions, enhancing overall user experience in the autocomplete system.
* Implement periodic status logging in autocomplete service
- Added a polling mechanism to log the status of the autocomplete engine at regular intervals.
- Enhanced logging to capture changes in phase, application name, suggestions, and errors, improving visibility during service execution.
- Refactored the `autocomplete_start_cli` function to integrate the new logging functionality, ensuring a more informative user experience while the service is running.
* Refactor memory dispatch logic and remove local memory implementation
- Updated the memory dispatch functions to utilize the new `memory_rpc` module, enhancing the handling of memory operations such as document management and namespace queries.
- Removed the local memory implementation, including database interactions and related functions, to streamline the codebase and improve maintainability.
- Introduced new RPC calls for document operations (put, list, delete) and context queries, ensuring a more efficient and consistent approach to memory management.
- This refactor aims to enhance the overall architecture and performance of the memory handling system.
* Remove macOS-specific overflow badge functionality and related helper functions
- Deleted the `show_overflow_badge` and `escape_applescript_string` functions, which were specific to macOS, to streamline the codebase.
- Refactored the `show_overflow_badge` function to provide a no-op implementation for non-macOS platforms, enhancing cross-platform compatibility.
- This change simplifies the autocomplete module by removing platform-dependent code, improving maintainability and clarity.
* Enhance text application logic in autocomplete module
- Updated the `apply_text_to_focused_field` function to improve interaction with focused UI elements on macOS.
- The new implementation retrieves the current value of the focused element and appends the provided text, ensuring better handling of text input.
- Enhanced error reporting to include stderr output when applying suggestions fails, improving debugging capabilities.
- These changes aim to provide a more robust and user-friendly experience in the autocomplete functionality.
* Refactor Landlock feature configuration for Linux support
- Moved the `landlock` and `rppal` dependencies under a conditional target configuration for Linux in both `Cargo.toml` files, ensuring they are only included when building for Linux.
- Updated the `landlock.rs` module to check for both the `sandbox-landlock` feature and the Linux target OS, improving the conditional compilation logic.
- This change enhances cross-platform compatibility and ensures that Landlock functionality is only available on supported systems.
* Update dependencies and enhance Tauri integration
- Updated the Tauri dependency in `Cargo.toml` to include the `tray-icon` feature, enabling system tray support.
- Introduced a new `rust-toolchain.toml` file to pin the Rust version to 1.93.0, ensuring compatibility with the matrix-sdk.
- Modified GitHub workflows to use the specified Rust version from `rust-toolchain.toml` instead of the stable version, improving build consistency.
- Refactored Tauri commands to utilize a new `wrapCommandResult` function for better response handling.
- Added a new `tray` module in `openhuman` for managing system tray functionality, enhancing the desktop experience.
- Updated various command implementations to streamline service management and improve error handling.
* Refactor core process handling and enhance encryption features
- Removed the `openhuman` dependency from `Cargo.lock` and `Cargo.toml`, streamlining the project structure.
- Updated the core process handling to fall back to a child process when in-process execution is unavailable, improving error handling and logging.
- Introduced new encryption commands (`ai_init_encryption`, `ai_encrypt`, `ai_decrypt`) to enhance security features, utilizing AES-GCM for data protection.
- Added a new `tray` module for managing system tray functionality, improving user experience on desktop platforms.
- Refactored various command implementations to improve service management and error handling, ensuring a more robust application architecture.
* Remove unused modules and refactor daemon host configuration
- Deleted the `daemon_host_config`, `memory`, `models`, `openhuman_daemon`, `tray`, `chat`, `conscious_loop`, and `runtime` modules to streamline the codebase.
- Refactored the daemon host configuration logic into the `openhuman` module, consolidating related functionality.
- Updated command implementations to utilize the new configuration methods, ensuring consistent handling of daemon host settings.
- This cleanup enhances maintainability and reduces complexity in the project structure.
* Refactor memory management and update Tauri dependencies
- Removed the `tray-icon` feature from the Tauri dependency in `Cargo.toml` to streamline the configuration.
- Deleted the `core:tray:default` capability from the default capabilities JSON, simplifying the capabilities structure.
- Refactored memory handling in tests to utilize `UnifiedMemory` instead of `SqliteMemory`, enhancing consistency across memory operations.
- Updated memory store, recall, and forget functionalities to support a global namespace, improving memory management and retrieval processes.
- Enhanced error handling and logging in memory operations to provide clearer feedback during execution.
* Remove AI encryption commands and related functionality
- Deleted the `ai_init_encryption`, `ai_encrypt`, and `ai_decrypt` functions to streamline the codebase and remove unused features.
- Updated the command registration in the `run` function to reflect the removal of these encryption commands, enhancing maintainability and reducing complexity.
* Add OAuth integration token handling and channel connection management
- Introduced functions to fetch and encrypt integration tokens using OAuth, enhancing security for token management.
- Updated the channel connections API to support OAuth integration, including listing, connecting, and disconnecting channels.
- Implemented checks for supported channels and authentication modes, improving the robustness of channel connection handling.
- Enhanced error handling for integration token retrieval to ensure required fields are present before proceeding.
* Refactor project structure and update documentation
- Renamed the project from "Outsourced" to "OpenHuman" and revised the project summary to reflect its focus on AI-powered assistance for crypto communities.
- Restructured the repository layout, detailing the purpose of each directory and its contents.
- Updated runtime scope to clarify platform support and Tauri's desktop-only focus.
- Enhanced documentation across various files, including architecture, services, and routing, to improve clarity and usability for contributors.
- Removed outdated sections and streamlined commands for development and production builds, ensuring consistency in the documentation.
* Implement REPL session management and multimodal support
- Introduced a new REPL session management system, allowing for session-specific interactions with agents.
- Added functions for starting, chatting, resetting, and ending REPL sessions, enhancing user experience and control.
- Implemented multimodal message handling, enabling the processing of images alongside text in user messages.
- Updated the project structure to include new modules for identity and multimodal functionalities, improving organization and maintainability.
- Enhanced error handling and logging for session operations, providing clearer feedback during execution.
* Refactor memory store implementation and introduce unified memory management
- Removed the legacy memory store implementation and replaced it with a new unified memory management system.
- Introduced a `MemoryClient` for handling document storage, retrieval, and namespace management.
- Added support for key-value storage and graph data structures within the unified memory framework.
- Enhanced the `UnifiedMemory` struct with methods for document upsertion, querying, and namespace operations.
- Updated the project structure to include new modules for memory types, factories, and traits, improving organization and maintainability.
- Improved error handling and logging across memory operations for clearer feedback during execution.
* Implement QuickJS skill instance management
- Removed the previous QjsSkillInstance implementation and replaced it with a new modular structure.
- Introduced separate modules for event loop management, instance handling, JavaScript handlers, and utility functions.
- Enhanced the event loop to efficiently manage QuickJS runtime tasks, including timer callbacks and message processing.
- Added support for asynchronous tool calls and lifecycle management within the QuickJS context.
- Improved error handling and logging throughout the new implementation for better debugging and user feedback.
- Updated documentation to reflect the new structure and functionality of the QuickJS skill instance.
|