9 Commits

Include renames

Author	SHA1	Message	Date
Steven EnamakelandGitHub	403f239ca5	refactor: remove QuickJS skills runtime (#508) ... * refactor: remove quickjs skills runtime * style: apply repo formatting * refactor: clean up error reporting and connection handling - Removed the 'skill' source option from the error report structure to streamline error reporting. - Refactored the ConnectionsPanel component to simplify connection status badge rendering and improve clarity. - Updated the CronJobsPanel to enhance logging for cron job loading processes. - Adjusted SkillCard component to use a more consistent type for icons. - Deleted outdated end-to-end tests for Gmail and Notion skills, improving test suite maintainability. * fix: remove unnecessary ESLint disable comment in Conversations component - Cleaned up the Conversations component by removing the ESLint disable comment for exhaustive dependencies in the useEffect hook, improving code clarity and maintainability. * fix: remove unnecessary whitespace in Conversations component - Eliminated an extra line of whitespace in the Conversations component, enhancing code readability and maintainability. * refactor: streamline SkillCard imports for improved clarity - Combined import statements in the SkillCard component to enhance code readability and maintainability.	2026-04-11 14:57:35 -07:00
3 people	0b23ae6b96	fix(voice): resolve dictation pipeline in embedded Tauri app (#466) ... * fix(voice): guard dictation_listener when voice_server is active macOS only supports one rdev::listen() global event tap per process. When voice_server.auto_start is true, skip starting the separate dictation_listener — the voice server owns the single listener and forwards hotkey events itself. Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com> * feat(voice): add TRANSCRIPTION_BUS broadcast channel Make publish_dictation_event public so the voice server can forward hotkey events. Add a new TRANSCRIPTION_BUS broadcast channel with subscribe_transcription_results() and publish_transcription() for delivering completed transcriptions to frontend clients via Socket.IO. Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com> * fix(voice): forward hotkey events and route transcription delivery In the voice server's hotkey handler, forward events to the dictation bus so Socket.IO clients receive dictation:toggle even without the separate dictation_listener running. In process_recording_bg, detect when the OpenHuman app is focused and deliver transcription via Socket.IO instead of OS-level Cmd+V paste, preventing text from disappearing into the unfocused WebView. Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com> * feat(voice): bridge transcription results to Socket.IO Subscribe to TRANSCRIPTION_BUS and emit dictation:transcription events to all connected Socket.IO clients. This completes the Rust-side pipeline for delivering transcribed text to the frontend. Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com> * fix(socket): queue listeners registered before socket connects Add a pendingListeners queue to socketService so that on()/once() calls made before the socket is established are replayed once the connection opens, preventing silently dropped event listeners. Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com> * fix(voice): use dedicated unauthenticated socket for dictation events Replace the auth-gated socketService dependency with a direct Socket.IO connection to the core process (127.0.0.1:7788). This bypasses the SocketProvider auth requirement and ensures dictation:toggle and dictation:transcription events are received regardless of login state. Dispatches the existing dictation://insert-text DOM event to bridge transcribed text into the Conversations chat input. Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com> * fix(voice): fallback to default audio config when preferred config fails macOS may advertise a 16kHz F32 config as supported but reject it at stream creation time (known cpal quirk). Add a fallback path that retries with the device's default_input_config(), handling F32, I16, and U16 sample formats with proper resampling. Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com> * fix(voice): add 3s timeout on Ollama LLM cleanup Wrap the Ollama inference call in a 3-second tokio::time::timeout so dictation feels responsive. If cleanup doesn't complete in time, fall back to raw Whisper text immediately instead of blocking for 2+ minutes. Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com> --------- Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>	2026-04-09 14:54:40 -07:00
3 people	b40449b3b7	feat(channels): complete Telegram Managed DM flow and realtime sync (#288) (#322) ... * feat(channels): extract shared constants to lib/channels/definitions Move FALLBACK_DEFINITIONS, STATUS_STYLES, and AUTH_MODE_LABELS from MessagingPanel into a shared module so both the settings panel and the upcoming Channels page can reuse them. Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com> * feat(channels): add ChannelStatusBadge, ChannelFieldInput, ChannelCapabilities Reusable UI primitives for the Channels page: status pill badge, credential form input, and capability chip list. Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com> * feat(channels): add useChannelDefinitions hook Shared hook that loads channel definitions and status from the core RPC, falls back to local definitions, and syncs Redux state. Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com> * feat(channels): add ChannelSelector with active route display Tab bar component showing Web / Telegram / Discord with connection status badges and active route summary. Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com> * feat(channels): add TelegramConfig and DiscordConfig with managed DM flow Channel-specific config panels with per-auth-mode credential fields, connect/disconnect, status badges, and error handling. TelegramConfig includes the managed DM deep link initiation flow. Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com> * feat(channels): add ChannelConfigPanel dispatcher and WebChannelConfig ChannelConfigPanel switches between Telegram/Discord/Web configs based on selection. WebChannelConfig shows a simple always-connected card. Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com> * feat(channels): add Channels page, route, and sidebar update Top-level /channels page with ChannelSelector + ChannelConfigPanel. Updates sidebar nav to point to /channels instead of /settings/messaging. Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com> * refactor(channels): simplify MessagingPanel with shared hook and components Replace inline loading logic with useChannelDefinitions hook, inline status badges with ChannelStatusBadge, and inline capability chips with ChannelCapabilities. Reduces duplication with the new Channels page. Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com> * fix(channels): keep managed dm in a reviewable UI state for #286 * style(channels): apply formatter output for #286 * feat(channels): complete telegram managed dm frontend flow (#288) * style(channels): apply formatter output for managed dm flow (#288) --------- Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>	2026-04-04 10:38:46 -07:00
Steven EnamakelandGitHub	ef708bdd20	refactor(core): move app state ownership into the Rust core (#320) ... * refactor(core): integrate CoreStateProvider and streamline state management - Replaced UserProvider with CoreStateProvider in App component to centralize state management. - Updated various components to utilize the new CoreStateProvider for accessing session tokens and user data. - Refactored hooks and components to eliminate direct Redux store dependencies, enhancing modularity and maintainability. - Introduced a new core state management structure to improve the handling of user authentication and onboarding states. This refactor aims to simplify state access across the application and improve overall code clarity. * fix: restore polyfills import and clean up component imports - Reintroduced the import of polyfills in main.tsx to ensure compatibility. - Adjusted import statements in PrivacyPanel and SocketProvider for consistency. - Simplified conditional expressions in TeamInvitesPanel and TeamMembersPanel for better readability. - Refactored CoreStateProvider and store.ts to streamline state initialization. - Enhanced formatting in various files for improved code clarity and maintainability. * refactor(tests): streamline onboarding and protected route tests - Updated OnboardingOverlay tests to utilize mock state management and simplify assertions. - Refactored ProtectedRoute tests to improve readability and ensure consistent use of mock state. - Enhanced teamApi tests to replace direct API calls with core RPC method calls, improving test isolation and clarity. - Adjusted socketSelectors tests to utilize a centralized core state snapshot for better state management during tests. * refactor(onboarding): simplify onboarding state management and improve loading logic - Removed unnecessary local state for onboarding completion in OnboardingOverlay, directly utilizing snapshot data. - Enhanced loading logic to prevent unnecessary renders and improve user experience during onboarding. - Updated PrivacyPanel to handle analytics consent persistence with error handling. - Refactored TeamManagementPanel and TeamPanel to improve team data fetching logic and loading states. - Streamlined CoreStateProvider to manage session token synchronization and state updates more effectively. * chore(deps): update tempfile dependency and refactor app state management - Added `tempfile` dependency to Cargo.toml for improved temporary file handling. - Refactored app state loading and saving functions to enhance error handling and ensure data integrity. - Introduced quarantine mechanism for corrupted app state files to prevent application crashes. - Updated URL parsing logic to ensure proper formatting of API URLs. - Adjusted type definitions in schemas for better clarity and consistency. * refactor(tests): simplify mock state usage in onboarding and protected route tests - Consolidated mock state management in OnboardingOverlay and ProtectedRoute tests for improved readability. - Streamlined assertions by reducing unnecessary lines in test setups. - Enhanced consistency in mock return values across tests to ensure clarity and maintainability. * refactor(tests): enhance PublicRoute tests with mock state and routing - Updated PublicRoute tests to utilize MemoryRouter for improved routing simulation. - Simplified mock state management by integrating `useCoreState` for user authentication scenarios. - Streamlined test assertions and removed redundant preloaded state configurations for clarity and maintainability. * refactor(tests): streamline mock state usage in PublicRoute and Mnemonic tests - Simplified mock state management in PublicRoute and Mnemonic tests for improved readability. - Consolidated mock return values to reduce redundancy and enhance clarity in test setups. - Improved consistency in the usage of `useCoreState` across test files. * Refactor billing components for improved readability - Cleaned up import statements in BillingPanel.tsx for better organization. - Enhanced formatting of billing plan descriptions in billingHelpers.ts for consistency. - Improved readability of conditional checks in BillingPanel component. * Refactor API endpoint handling for clarity and consistency - Updated references from `/settings` to `/auth/me` in various modules to standardize user authentication flows. - Renamed `parse_settings_response_json` to `parse_api_response_json` for improved clarity in response handling. - Adjusted user ID extraction functions to reflect the new endpoint structure, enhancing maintainability across the codebase. - Updated test cases to align with the new endpoint naming conventions, ensuring consistency in API interactions.	2026-04-04 03:20:18 -07:00
3 people	8381283c52	Fix/update api (#319) ... * feat(webhooks): refactor webhook URL handling and enhance API endpoints - Introduced a new utility function `buildWebhookIngressUrl` to standardize the construction of webhook URLs across components. - Updated `WebhooksDebugPanel` and `TunnelList` components to utilize the new URL builder for improved consistency and maintainability. - Refactored API endpoints in `tunnelsApi` to reflect changes in webhook routing, ensuring all references to tunnel management are aligned with the new structure. - Adjusted user API calls to replace `/telegram/me` with `/auth/me` for better clarity and consistency in authentication flows. - Enhanced socket service to normalize channel connection update payloads, improving error handling and data integrity. These changes streamline webhook management and enhance the overall developer experience when working with webhooks. * feat(messaging): enhance Telegram and Discord channel linking functionality - Added support for managed DM linking with Telegram and OAuth flow for Discord. - Introduced `createChannelLinkToken` API to generate short-lived link tokens for messaging channels. - Updated `MessagingPanel` to handle managed linking flows, including building launch URLs and user instructions. - Enhanced configuration to include a Telegram bot username for fallback linking. - Updated tests to mock new configuration values for consistent testing. These changes improve the user experience for linking messaging channels and streamline the authentication process. * feat(api): introduce core command client and refactor API calls - Added a new `coreCommandClient` to facilitate RPC calls to core services. - Refactored existing API endpoints in `authApi`, `billingApi`, `creditsApi`, `tunnelsApi`, and `userApi` to utilize the new command client for improved consistency and maintainability. - Updated the billing API to include new endpoints for fetching balance, transactions, and managing auto-recharge settings. - Enhanced the user API to streamline user data retrieval. - Improved error handling and logging across the refactored API calls. These changes enhance the overall architecture of the API services, making them more modular and easier to maintain. * refactor(api): streamline API calls and enhance error handling - Refactored `creditsApi` and `tunnelsApi` to ensure consistent use of the new core command client. - Updated API methods to improve error handling and response parsing. - Introduced a new `authed_json` method in `BackendOAuthClient` for standardized authenticated requests. - Cleaned up unused imports and optimized code structure across various modules. These changes enhance the maintainability and reliability of the API services. * refactor(api): streamline API calls and improve code readability - Reorganized API calls in `authApi`, `billingApi`, `creditsApi`, and `tunnelsApi` to enhance consistency and maintainability. - Updated function formatting for better readability, ensuring parameters are clearly defined. - Cleaned up import statements and removed unnecessary line breaks to improve code clarity. These changes contribute to a more maintainable codebase and enhance the overall developer experience. * refactor(MessagingPanel): clean up imports and remove unused constants - Reorganized import statements for clarity and consistency. - Removed unused constants related to channel definitions and status styles to streamline the component. - Simplified the `updateField` function call in the rendering logic for better readability. These changes enhance the maintainability of the MessagingPanel component. * fix: restore helper functions removed during merge cleanup buildManagedChannelLaunchUrl and buildManagedChannelInstruction were stripped by the linter after merge resolution, breaking the build. Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com> * feat(messaging): enhance MessagingPanel with pending instruction handling - Introduced a new state for pending instructions to improve user feedback during channel connection processes. - Updated error handling to ensure users receive clear instructions, including URLs for manual access if automatic opening fails. - Refactored connection status updates to streamline the dispatch process and improve code readability. - Enhanced the rendering logic to display pending instructions in the UI, providing better context for users during authentication flows. * fix(api): encode channel and ID parameters in webhook and OAuth URLs - Updated the URL construction in the BackendOAuthClient to encode the channel parameter, ensuring proper formatting for requests. - Modified the get_tunnel, update_tunnel, and delete_tunnel functions to encode the ID parameter in webhook URLs, enhancing security and compatibility with special characters. * fix(auth): validate channel input for link token creation - Added validation to ensure the channel is not empty and is one of the supported types (telegram, discord). - Converted the channel string to lowercase for consistent matching. - Updated the call to create_channel_link_token to use a reference to the channel variable. * chore(todos): update TODO list with completed tasks and new feature requests - Marked several tasks as completed, including integration of the custom memory engine and skills registry into the core. - Added new items to the TODO list, including improvements for voiceover functionalities, screen intelligence, and Gmail skill enhancements. - Included tasks for debugging skills from the UI and improving prompts to reduce hallucinations. * refactor(webhooks): improve formatting of get_tunnel function for readability - Reformatted the get_tunnel function to enhance code clarity by adjusting the indentation and line breaks in the call to get_authed_value. - This change improves the maintainability of the code and aligns with the overall code style. * test(userApi): enhance userApi tests with improved mocking and error handling - Added a mock function for core command calls to streamline test setup. - Introduced a helper function to generate mock user data for consistent test cases. - Updated tests to use the mock function for simulating API responses, improving clarity and maintainability. - Enhanced error handling in tests to cover various API error scenarios, ensuring robustness in userApi.getMe functionality. * refactor(billingApi): update tests to use core command mocking and improve error handling - Replaced apiClient mocks with core command mocks for better alignment with the new API structure. - Updated test cases to reflect changes in API call expectations, enhancing clarity and maintainability. - Improved error handling in tests to ensure proper propagation of errors from core command calls. * refactor(billingApi): simplify test cases by consolidating mock function calls - Streamlined mock function calls in billingApi tests for improved readability and consistency. - Removed unnecessary line breaks in mock responses, enhancing clarity in test definitions. - Ensured that error handling and API call expectations are clearly represented in the tests. * refactor(api): rename settings endpoint to current_user for clarity - Updated the endpoint handling authenticated profile fetches to improve clarity in the codebase. - Adjusted the routing to reflect the new function name, enhancing maintainability and understanding of the API's purpose. --------- Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>	2026-04-04 02:59:31 -07:00
Mega MindandGitHub	04146bf0bf	Fix/191 skills reliability upstream (#282) ... * feat(skills): core RPC data stats, tool timeout env, ping state merge (#191) - Add openhuman.skills_data_stats and SkillDataDirectoryStats (disk usage). - Centralize tool execution timeout via OPENHUMAN_TOOL_TIMEOUT_SECS (tool_timeout). - Apply timeout to skill event loop, agent tool loop, harness default, delegate. - Ping scheduler: merge connection_error into published_state via registry. - JSON-RPC e2e: assert skills_data_stats. Closes #214 Closes #218 Part of #213 (backend) Made-with: Cursor * feat(app): skills sync stats UI, reconnect resync, FE timeouts, chat errors (#191) - useSkillDataDirectoryStats + Skills.tsx merge disk stats with skill state. - resyncRunningSkillsAfterReconnect on socket connect; disconnectSkill OAuth cleanup in finally. - withTimeout for callTool/triggerSync; VITE_TOOL_TIMEOUT_SECS in app .env.example. - Structured ChatSendError in Conversations (data-chat-send-error-code). Closes #213 Closes #215 Closes #216 Closes #217 Closes #219 Made-with: Cursor * test(e2e): onboarding helpers and skills smoke specs (#191) - shared-flows: 5-step onboarding, completeOnboardingIfVisible. - auth-access-control + voice-mode use shared helpers. - skills-registry: named skill assertion; new skill-oauth, multi-round, reconnect, lifecycle specs. Closes #220 Closes #221 Closes #222 Closes #223 Closes #224 Part of #189 (E2E helpers) Made-with: Cursor * style: rustfmt + Prettier for CI (PR #282) Fix Type Check workflow: prettier --check and cargo fmt --check. Made-with: Cursor * fix: PR #282 review — tool timeout config, tool_timeout module, CI diagnostics - Centralize VITE_TOOL_TIMEOUT_SECS in config.ts (TOOL_TIMEOUT_SECS) - Move tool_timeout to folder module; merge_published_state broadcasts SKILL_STATE_CHANGED - Resync guard after socket reconnect; qjs_engine logs data dir stat errors - E2E: registry/lifecycle/multi-round failure diagnostics; onboarding label constant - chatSendError arrow export; rustfmt/import grouping in event_loop Made-with: Cursor * test(e2e): add Gmail skill end-to-end tests - Introduced a comprehensive end-to-end test suite for the Gmail skill, covering the full lifecycle from discovery to OAuth completion and email management. - Implemented two modes: a lifecycle-only mode that validates the skill's event loop without real credentials, and a live mode that interacts with the Gmail API using actual credentials. - Added detailed environment variable requirements and usage instructions for both testing modes. Closes #XXX (replace with relevant issue number if applicable)	2026-04-02 15:25:31 -07:00
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	2026-03-29 20:22:38 -07:00
Steven EnamakelandGitHub	7bcf43314a	Improve service lifecycle E2E coverage and align CI workflows (#62) ... * Add JSON-RPC schema definition and HTTP schema endpoint - Introduced a new `schema.json` file containing detailed definitions for various JSON-RPC methods, including their inputs, outputs, and descriptions. - Implemented a new HTTP endpoint `/schema` in the core server to serve the JSON-RPC schema, enhancing API documentation and accessibility. - Updated the core HTTP router to include the new schema route, improving the overall structure and usability of the API. - Enhanced error handling and response formatting in the server to ensure consistent feedback for schema requests. * Update TypeScript configuration and refactor core RPC client - Changed TypeScript target from ES2020 to ESNext and updated library references in `tsconfig.json` for improved compatibility with modern features. - Refactored `coreRpcClient.ts` to enhance JSON-RPC request handling, including the introduction of legacy method aliases and improved error handling. - Updated API service methods in `authApi.ts` and `channelConnectionsApi.ts` to utilize the new core RPC client structure, streamlining authentication and channel connection processes. - Added new utility functions for managing JSON-RPC requests and responses, improving code organization and maintainability. - Enhanced test coverage for the new RPC client methods and refactored existing tests to align with the updated structure. * Enhance Tauri configuration and refactor daemon program arguments - Updated `tauri.conf.json` to include additional macOS infoPlist settings for better application identification and icon management. - Refactored the `daemon_program_args` function in `common.rs` to improve clarity by renaming the parameter to `_exe`, indicating it is unused. This change enhances code readability and maintainability. * Refactor Tauri configuration by removing unused macOS infoPlist settings - Updated `tauri.conf.json` to streamline macOS configuration by removing unnecessary infoPlist entries while retaining essential settings for the application. - This change enhances clarity and maintainability of the Tauri configuration file. * Enhance authentication flow and testing documentation - Introduced a new `isAuthBootstrapComplete` state in the authentication slice to manage the completion of the authentication bootstrap process. - Updated the `UserProvider` to set the `isAuthBootstrapComplete` state based on the authentication status, improving session restoration logic. - Modified route components (`DefaultRedirect`, `ProtectedRoute`, `PublicRoute`) to conditionally render based on the `isAuthBootstrapComplete` state, enhancing user experience during the authentication process. - Added a comprehensive testing guide in `CLAUDE.md`, detailing unit and E2E testing practices, including setup, authoring rules, and a checklist for test coverage. - Updated the `SettingsHome` component to redirect to the home page instead of the login page upon logout, streamlining user navigation. - Enhanced the `LocalModelPanel` to track download progress and manage local AI assets more effectively, improving overall functionality. * Add resolutions for @tauri-apps/api dependency in package.json - Introduced a resolutions field in package.json to enforce the use of @tauri-apps/api version 2.10.1, ensuring compatibility across workspaces. - Updated dependencies in app/package.json to include @tauri-apps/api version 2.10.1, aligning with the new resolution. - Adjusted yarn.lock to reflect the updated version of @tauri-apps/api, enhancing dependency management and consistency. * Refactor Tauri configuration and enhance E2E build process - Updated `tauri.conf.json` to remove unused resource paths, streamlining the configuration for better maintainability. - Modified `wdio.conf.ts` to improve application path resolution for macOS, allowing for multiple bundle base checks to enhance compatibility. - Refactored `e2e-build.sh` to disable updater artifacts for E2E builds and introduced a conditional cargo clean mechanism, improving build efficiency and clarity. * Enhance E2E testing setup and documentation - Updated `CLAUDE.md` to clarify the default behavior of `OPENHUMAN_WORKSPACE` in `e2e-run-spec.sh`, emphasizing automatic creation and cleanup for reproducible E2E runs. - Modified `e2e-run-spec.sh` to implement automatic temporary workspace creation when `OPENHUMAN_WORKSPACE` is not set, improving usability for debugging and testing. - Enhanced cleanup logic in `e2e-run-spec.sh` to ensure proper removal of temporary workspaces after tests, contributing to a cleaner testing environment. * Implement shared mock backend for testing and enhance documentation - Introduced a shared mock backend for unit and integration tests, allowing for deterministic API behavior across app and Rust tests. - Updated `CLAUDE.md` to include detailed instructions on using the shared mock backend, including key admin endpoints and manual run commands. - Modified `package.json` to add scripts for running the mock API server and Rust tests with the mock backend. - Refactored test setup to utilize the new mock backend, improving test reliability and isolation. - Removed obsolete MSW handlers and server setup, streamlining the testing framework. * Enhance authentication state management and testing coverage - Introduced `isAuthBootstrapComplete` state in the authentication slice to track the completion of the authentication process. - Updated `ProtectedRoute` and `PublicRoute` components to utilize the new state, improving user experience during authentication. - Enhanced test cases for `ProtectedRoute` and `PublicRoute` to reflect the updated authentication state structure. - Added a new end-to-end test for the authentication flow, ensuring proper handling of OAuth tokens and session management. - Improved mock setup in tests to better simulate authentication scenarios, enhancing test reliability and coverage. * Enhance README.md with architecture overview and component roles - Added detailed descriptions of the OpenHuman architecture, highlighting the separation of business logic and UI components. - Explained the roles of Rust and the UI in the monorepo, including the use of JSON-RPC, QuickJS, Vite, React, and Tauri. - Documented the structure of controllers and the RPC surface, emphasizing the shared contract for automation and testing. - Provided links to further documentation for architecture, frontend structure, and Tauri commands. * Integrate ServiceBlockingGate component and enhance loading states - Added the `ServiceBlockingGate` component to manage service availability and display appropriate loading screens. - Updated `DefaultRedirect`, `ProtectedRoute`, and `PublicRoute` components to show a loading indicator while authentication bootstrap is in progress. - Implemented timeout handling in `UserProvider` for improved authentication state management. - Introduced tests for `ServiceBlockingGate` to ensure proper rendering and functionality under various service states. * Implement core RPC URL resolution and default hash route handling - Added a function to resolve the core RPC URL based on the environment, improving flexibility for Tauri and non-Tauri contexts. - Introduced a default hash route handler in the main application entry point to ensure proper navigation behavior. - Updated the core RPC command to expose the resolved RPC URL, enhancing the integration with the frontend. - Refactored the core RPC client to utilize the new URL resolution logic, ensuring consistent API calls. * Refactor backend URL usage to API_BASE_URL - Replaced all instances of BACKEND_URL with API_BASE_URL across various components and services to standardize API endpoint references. - Updated OAuth provider configurations, settings panels, hooks, and services to ensure consistent API calls. - Enhanced test setups to reflect the new API_BASE_URL, improving test reliability and alignment with the updated configuration. * Implement RouteLoadingScreen for improved loading states - Introduced a new `RouteLoadingScreen` component to provide a consistent loading experience across various routes. - Updated `DefaultRedirect`, `ProtectedRoute`, and `PublicRoute` components to utilize `RouteLoadingScreen` while waiting for authentication bootstrap completion. - Enhanced `MiniSidebar` to hide on additional public/setup routes, improving user navigation experience. - Refactored `UserProvider` to streamline authentication state management by removing unnecessary references. * Add feature design workflow section to CLAUDE.md - Introduced a comprehensive workflow for feature design, outlining steps from specification to UI implementation and testing. - Emphasized the importance of grounding designs in existing codebases and defined planning rules for E2E scenarios. - Provided detailed instructions for implementing features in Rust, conducting JSON-RPC tests, and building UI components in the Tauri app. * Refactor backend URL handling and improve OAuth flow - Replaced static API_BASE_URL references with dynamic backend URL resolution across various components and services, enhancing flexibility for Tauri and non-Tauri environments. - Updated OAuth provider configurations to utilize the new backend URL logic, ensuring consistent login URL generation. - Refactored API client and socket service to fetch the backend URL dynamically, improving reliability in different deployment contexts. - Introduced a new service for resolving the backend URL, streamlining the configuration and enhancing test setups. * Add debug logging guidelines to CLAUDE.md - Introduced comprehensive guidelines for implementing development-oriented debug logging in both Rust and the app. - Emphasized the importance of logging at appropriate levels (`debug`/`trace`) and following existing patterns for consistency. - Provided instructions on avoiding sensitive information in logs and ensuring terminal output is grep-friendly for easier debugging during development. * Enhance service management with new mock functionality and E2E tests - Added a mock service manager to facilitate deterministic service behavior during end-to-end tests, enabling better simulation of service states. - Introduced new buttons in the `ServiceBlockingGate` component for restarting and uninstalling services, improving user control over service management. - Implemented a comprehensive E2E test suite for the service connectivity flow, covering installation, starting, stopping, restarting, and uninstalling services. - Updated package scripts to include a new E2E test for service connectivity, enhancing testing coverage and reliability. - Refactored service operations to support mock functionality, ensuring consistent behavior across testing and production environments. * Enhance ServiceBlockingGate with improved logging and periodic health polling - Introduced periodic health polling in the `ServiceBlockingGate` component to refresh service status every 3 seconds, enhancing responsiveness to service state changes. - Added detailed logging for various operations, including service status checks and error handling, to improve traceability and debugging. - Updated E2E tests to include logging steps for better visibility during service connectivity flow tests. - Refactored error handling to ensure consistent logging of error messages across service operations. * Refactor E2E testing scripts and enhance CLAUDE.md documentation - Updated paths in CLAUDE.md to reflect the new location of the E2E run script, ensuring accurate instructions for running tests. - Removed outdated E2E test scripts from package.json and migrated relevant functionality to app/package.json for better organization. - Introduced new E2E testing scripts for specific flows (auth, login, payment, etc.) to streamline testing processes and improve modularity. - Added a script to run all E2E flows sequentially, enhancing test coverage and simplifying execution. - Improved documentation for E2E testing procedures in CLAUDE.md, providing clearer guidance for developers. * Refactor imports and enhance code readability - Removed duplicate import of `ServiceBlockingGate` in `App.tsx` for cleaner code. - Improved readability in `MiniSidebar.tsx` by formatting conditional statements. - Reordered imports in `PublicRoute.tsx` for consistency. - Enhanced formatting in `ServiceBlockingGate.tsx` for better clarity in asynchronous operations. - Streamlined import statements in various test files and components for improved organization. - Updated `LocalModelPanel.tsx` to enhance button disable logic readability. - Refactored CORS headers in `jsonrpc.rs` for better formatting. * ci: align build and test workflows with app workspace e2e * ci: align release and typecheck workflows with current workspace * Enhance ServiceBlockingGate functionality with improved refresh options - Introduced a new `RefreshOptions` type to customize the behavior of the `refreshStatus` function, allowing for conditional error clearing and status checking. - Updated the `refreshStatus` function to utilize the new options, enhancing control over service state updates. - Modified the button click handler to pass the new options, improving user experience during service refresh operations. - Adjusted state updates to prevent unnecessary re-renders and maintain consistency in service state management. * Refactor RefreshOptions type for improved clarity in ServiceBlockingGate - Consolidated the definition of the `RefreshOptions` type into a single line for better readability. - Maintained existing functionality while enhancing code clarity in the `ServiceBlockingGate` component.	2026-03-29 18:14:13 -07:00
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.	2026-03-29 10:30:18 -07:00