Steven EnamakelandGitHub
acfa5497ef
* feat(auth): implement advanced authentication modes and UI selector - Introduced a new `AuthModeSelector` component for selecting authentication methods (managed, self-hosted, text). - Enhanced the `SkillManager` to handle revocation of both OAuth and auth credentials. - Updated the API to support advanced auth configurations with multiple modes. - Added functionality to persist and restore auth credentials in the skill's data directory. - Updated relevant types and interfaces to accommodate the new auth structure. * feat(auth): enhance SkillSetupWizard with multi-phase authentication flow - Updated `SkillSetupWizard` to support a two-phase authentication process: an optional auth mode selection followed by the setup phase. - Integrated `AuthModeSelector` for users to choose between managed, self-hosted, and text authentication methods. - Improved state management to handle various auth phases, including error handling and transitions to the setup phase upon successful authentication. - Refactored relevant types and interfaces to accommodate the new authentication structure. * refactor(skills): remove unused loader module and clean up bridge imports - Deleted the unused `loader.rs` module, which was reserved for future ES module import support. - Removed references to the `loader` module in `mod.rs`. - Cleaned up the `bridge` module by removing several unused bridge files, including `cron_bridge.rs`, `db.rs`, `log_bridge.rs`, `skills_bridge.rs`, `store.rs`, and `tauri_bridge.rs`. - Added comprehensive tests for the `manifest.rs`, `ops.rs`, and `preferences.rs` modules to ensure functionality remains intact after the refactor. * feat(registry): introduce registry cache management for remote skill registry - Added a new `registry_cache.rs` module to handle disk-based caching for the remote skill registry. - Implemented functions for managing cache, including reading, writing, and checking cache freshness. - Updated `registry_ops.rs` to utilize the new caching functions, improving performance and reducing redundant network calls. - Introduced a new `event_loop` module to manage the QuickJS runtime, including handling incoming messages and persisting state to memory. - Added webhook request handling and RPC message handlers to facilitate communication with external services. - Removed the obsolete `event_loop.rs` file, consolidating functionality into the new structure. * fix(tests): update imports in registry_ops tests to include cache management functions - Modified test module imports in `registry_ops.rs` to include new cache management functions from `registry_cache`. - This change ensures that tests can utilize the updated caching functionality introduced in the recent registry cache management feature. * chore(deps): update OpenHuman version to 0.51.6 and clean up code formatting - Updated the OpenHuman dependency version in `Cargo.lock` to 0.51.6. - Refactored code in several files for improved readability by adjusting formatting and removing unnecessary line breaks. - Ensured consistent logging format in `event_loop` and `rpc_handlers` modules for better clarity in log messages. * refactor(conversations): improve team usage display logic and formatting - Refactored the Conversations component to enhance the display of team usage information, including clearer conditional rendering for budget exhaustion messages. - Improved formatting of budget display for both 5-hour and weekly limits, ensuring consistent presentation. - Streamlined the import of the core HTTP base URL in the WebhooksDebugPanel for better code organization. * refactor(auth): enhance credential management and validation process - Updated the SkillManager to attempt revoking auth credentials even if the auth mode is unknown, improving robustness. - Introduced a new deserialization function to ensure that at least one authentication mode is provided in the SkillAuthConfig. - Enhanced the handling of temporary credential injection during the auth completion process, ensuring credentials are only persisted upon successful validation. - Improved the handling of OAuth credentials in JavaScript, ensuring stale credentials are cleared for non-managed modes. - Added checks for existing Authorization headers to prevent redundant injections in self-hosted modes. * test(manifest): add unit tests for authentication mode deserialization - Introduced tests to validate the deserialization of known authentication modes in the SkillManifest. - Added checks to ensure invalid authentication types and empty mode lists are correctly rejected. - These tests enhance the robustness of the authentication configuration handling in the manifest module. * refactor(messaging): simplify MessagingPanel by removing unused constants and improving input handling - Removed unused constants related to channel statuses, authentication modes, and fallback definitions to streamline the MessagingPanel component. - Updated input handling to use a more concise onChange function, enhancing code readability. - Commented out placeholder and className properties for input fields to improve clarity and focus on essential functionality. * refactor(webhooks): streamline TunnelList imports for improved clarity - Combined the import statements for Tunnel type and tunnelsApi from the same module into a single line, enhancing code readability and organization.
OpenHuman
The age of super intelligence is here. OpenHuman is your Personal AI super intelligence. Private, Simple and extremely powerful.
Discord • Reddit • X/Twitter • Docs
"The Tet. What a brilliant machine" — Morgan Freeman as he reminisces about alien superintelligence in the movie Oblivion
Early Beta — Under active development. Expect rough edges.
To install or get started, either download from the website over at tinyhumans.ai/openhuman or run
# For MacOS/Linux
curl -fsSL https://raw.githubusercontent.com/tinyhumansai/openhuman/main/scripts/install.sh | bash
# For Windows
irm https://raw.githubusercontent.com/tinyhumansai/openhuman/main/scripts/install.ps1 | iex
What is OpenHuman?
OpenHuman is an open-source agentic assistant that is designed to integrate with you in your daily life. Here's what makes OpenHuman special:
-
One subscription, many providers — One assistant wired to skills and backend models so you are not juggling a separate subscription stack for every integration surface.
-
Incredible memory — Rust-side memory (store / recall / namespaces) plus optional TinyHumans Neocortex-backed context when configured, so the agent can retain and retrieve more than a single chat window. Channels and ongoing conversations feed the same loop so day-to-day context does not reset every session.
-
Screen intelligence — Regular screen capture (on a cadence or when triggered) feeds an on-device pipeline that understands what is on screen, distills it into memory (facts, UI state, workflows), and can propose actions the agent executes for you. OS permissions and capture APIs vary by platform; the goal is your machine first, not shipping raw frames to the cloud by default.
-
Voice & meetings — A Local-model speech stack (listen / TTS) let the assistant talk back and capture or work with meeting audio with a privacy-first default when you route inference locally. Transcripts and summaries land in the same memory + agent loop so OpenHuman can follow up: tasks, drafts, calendar nudges, or skill-backed workflows—without treating a meeting as a one-off chat.
-
Memory-aware autocomplete — Keyboard autocomplete is built for right-context suggestions: it consults memory namespaces and recent context so completions stay aligned with you, your workspace, and prior sessions—not a blank model every keystroke.
-
Runs a local AI model — The Rust core exposes local AI paths (and the desktop bundle can ship local/bundled runners where applicable) for the workloads above—vision snippets, speech helpers, summarization, tooling—so sensitive steps can stay off the cloud when you choose.
-
Simple or advanced — Skill setup wizards and defaults for common tools, with room to go deeper via settings, credentials, and core RPC when you need control and privacy.
Architecture: docs/ARCHITECTURE.md. Contributor orientation: CONTRIBUTING.md.
Under the hood (Architecture)
OpenHuman is a desktop monorepo: Rust owns business logic and execution; the UI owns interaction, layout, and OS integration.
Rust (openhuman / openhuman_core). The repo root src/ crate is the brain: JSON-RPC over HTTP (core_server), domain modules (auth, config, memory, skills, channels, screen intelligence, local AI, cron, …), and a QuickJS runtime for sandboxed JavaScript skills. The openhuman binary is built and staged next to the Tauri app so the desktop shell can spawn it as a sidecar. Heavy work—SQLite, sockets, crypto, skill lifecycle—runs there under Tokio, not in the WebView.
UI (app/). Vite + React (TypeScript) implements screens, onboarding, settings, and realtime UX. Redux Toolkit holds client state; Socket.io and the MCP-style client stack stay in sync with the core’s realtime surface. Tauri v2 (app/src-tauri/) is a thin Rust host: windowing, filesystem hooks where needed, and core_rpc_relay—forwarding JSON-RPC from the WebView to the openhuman process so the UI never re-implements domain rules.
Controllers and the RPC surface. Features are exposed as registered controllers: each domain declares schemas (namespace, function name, parameter shapes) and a handler. At runtime, calls are validated, dispatched by method name (e.g. openhuman.auth_get_state, openhuman.local_ai_agent_chat), and return structured outcomes. CLI and HTTP share the same controller catalog, so automation, tests, and the app all hit one contract.
What ties it together: one registry of controllers, one sidecar process for execution, Tauri IPC for shell-only capabilities, and HTTP JSON-RPC for everything else—plus skills and dual-socket behavior documented in the architecture guide.
Read more: docs/ARCHITECTURE.md · Frontend tree: docs/src/README.md · Tauri commands: docs/src-tauri/README.md
Contributors Hall of Fame
Show some love and end up in the hall of fame