- Add JSON-RPC handlers for source, global, and topic-based memory retrieval.
- Integrate Ollama embeddings for semantic reranking of chunks and summaries.
- Implement 15 unit tests for RPC handlers covering parameter parsing and PII redaction.
- Redact PII from logs by removing raw source, entity, and node identifiers.
- Fix BFS traversal for drill-down and deduplicate results in topic queries.
- Add configuration for embedding endpoints, models, and strictness modes.
Co-authored-by: sanil-23 <sanil@vezures.xyz>
Co-authored-by: Steven Enamakel <enamakel@tinyhumans.ai>
* feat(webview_accounts): native OS notifications from embedded webviews (#714)
Forward CEF notification intercept payloads to tauri-plugin-notification,
prefixing the title with the provider label so the source of each toast is
obvious at a glance. Honour `silent` (skip toast, still record route),
`icon` (passed through to the native builder), and `tag` (used as the
dedup key, with a monotonic timestamp fallback for untagged payloads).
Record a NotificationRoute keyed by `{provider}:{account_id}:{tag_or_uuid}`
so a future click hook (UNUserNotificationCenter / notify-rust on_response)
can route the OS click back to the source account. Entries are cleared on
webview_account_close / _purge to bound map growth.
Expose webview_notification_permission_state / _request commands mapping
tauri::plugin::PermissionState onto the web API triple. Non-cef stubs
return "default" so the frontend can call the same invoke names on both
runtimes. Wire notification:allow-* capabilities so the plugin can be
invoked from the webview.
Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
* feat(accounts): wire notification permission + click bridge (#714)
Round-trip the OS notification permission once per session on first
account open via the new invoke pair. Attach a dormant notification:click
listener that dispatches setActiveAccount and brings the main window to
front when a platform click hook starts emitting the event — contract
matches the Rust NotificationRoute shape so the emit side is a one-liner.
Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
* chore: sync Cargo.lock to 0.52.26 after version bump
Lockfile picked up the pending 0.52.26 version bump from Cargo.toml
while building the notification feature. No dependency graph change.
Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
* feat(notifications): add notification bypass for embedded webview apps (#679)
- Add NotificationBypassPrefs (global DND, per-account mute, bypass-when-focused)
to WebviewAccountsState with thread-safe AtomicBool window focus tracking
- Evaluate all three bypass conditions inside forward_native_notification before
showing OS toast; each suppression path logs at debug with [notify-bypass] prefix
- Add four new Tauri commands: webview_notification_set_dnd,
webview_notification_mute_account, webview_notification_get_bypass_prefs,
webview_set_focused_account
- Wire window focus tracking in setup hook via on_window_event Focused handler
- Frontend: add setAccountMuted, setGlobalDnd, getBypassPrefs, setFocusedAccount
helpers in webviewAccountService; sync focused account on open + click
- Add NotificationsPanel settings page with Global DND toggle
- Register NotificationsPanel at /settings/notifications
Closes#679
* feat(notifications): integrate notifications feature into app
- Added Notifications page and routing to AppRoutes.
- Introduced NotificationRoutingPanel in Settings for managing notification settings.
- Updated SettingsHome to include navigation for notification routing.
- Integrated notifications reducer into the store for state management.
- Enhanced Rust backend to support notification handling from embedded webviews.
This commit lays the groundwork for a comprehensive notification system within the application.
* refactor(notifications): clean up code formatting and structure
- Simplified JSX structure in NotificationCard for better readability.
- Consolidated fetchNotifications call in NotificationCenter for cleaner syntax.
- Improved formatting in NotificationRoutingPanel and notificationsSlice for consistency.
- Enhanced Rust code readability by streamlining function signatures and logic.
These changes enhance code maintainability and readability across the notifications feature.
* refactor(webview_accounts): simplify webview_notification_set_dnd function signature
- Removed unnecessary line breaks in the webview_notification_set_dnd function for improved readability.
* feat(notifications): implement provider-level notification settings management
- Added `getNotificationSettings` and `setNotificationSettings` functions to manage notification settings for providers.
- Enhanced `NotificationRoutingPanel` to display and update settings for Gmail, Slack, Discord, and WhatsApp.
- Introduced new RPC endpoints for retrieving and updating notification settings.
- Updated database schema to store notification settings persistently.
This commit establishes a robust system for managing notification preferences, improving user control over notifications.
* refactor(notifications): improve code formatting and readability
- Enhanced formatting in NotificationRoutingPanel for better clarity.
- Streamlined function signatures in notificationService and Rust backend.
- Improved readability of assertions in tests by adjusting line breaks.
These changes contribute to a more maintainable and comprehensible codebase for the notifications feature.
* chore(vendor): bump tauri-cef to fix Slack notification permission banner
Updates the tauri-cef submodule to 55db2d6 which adds a
navigator.permissions.query shim in the CEF render process. Slack checks
this API (not just Notification.permission) to decide whether to show its
"needs your permission" banner — the shim returns "granted" for
notifications queries so the banner no longer appears.
Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
* chore(vendor): bump tauri-cef for cargo fmt fixes
Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
* chore(vendor): bump tauri-cef — native V8 permissions.query shim
Switches from context.eval() to a proper PermissionsQueryV8Handler so
the navigator.permissions.query fix actually runs in on_context_created.
Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
* fix(notifications): patch navigator.permissions.query in ua_spoof.js
The V8 set_value_bykey approach in cef-helper's on_context_created does
not stick on CEF platform objects (Chromium's V8 binding layer silently
ignores property writes on native wrappers like Permissions). The init
script path via frame.execute_java_script runs in the fully-initialised
JS context where navigator.permissions IS writable, matching how
ua_spoof.js already overrides navigator.userAgent successfully.
Slack checks navigator.permissions.query({ name: 'notifications' })
before showing its "needs permission" banner — patching it here to
return "granted" removes the banner.
Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
* fix(notifications): use Object.defineProperty to shim navigator.permissions
Two-layer fix for the Slack "needs permission to enable notifications" banner:
1. cef-helper (submodule update to 99a2686): context.eval() in
on_context_created installs Object.defineProperty(navigator, 'permissions',
...) before any page JS runs.
2. ua_spoof.js: same Object.defineProperty pattern as belt-and-suspenders
for frames that reload or trigger permission checks after on_load_end.
Simple property assignment on Blink platform objects is silently ignored;
Object.defineProperty on the navigator wrapper itself (the same mechanism
already used for navigator.userAgent) works correctly.
Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
* fix(notifications): address CodeRabbit review issues on PR #727
- Move raw_title out of log::info! (PII risk) — log title_chars at info,
raw_title at debug only
- Fix permissionChecked set before async invoke in ensureNotificationPermission
so transient failures allow retry on next account open
* fix(cef): enable webview-data-url feature for CEF placeholder URL
The CEF backend uses a data: URL as the initial webview location so CDP
can attach before the real provider URL loads. Tauri's add_child rejects
data: URLs unless the webview-data-url feature is enabled.
* fix(notifications): address remaining CodeRabbit issues on PR #727
- cdp/emulation: bump Chrome UA 124→136 to pass Slack browser check
- cdp/session: inject Page.addScriptToEvaluateOnNewDocument to stub
Notification.permission as "granted" and silence provider banners
- notifications/mod.rs + core/all.rs: wire notifications domain into
the controller registry (fixes unknown-method in json_rpc_e2e tests)
- notifications/schemas: add skipped bool output to ingest schema
- notifications/store: add tracing::warn on datetime parse failure
- notificationService: union return type for ingestNotification
- webviewAccountService: narrow union before accessing result.id
- NotificationCenter: drive loading/error from fetch effect; track
allProviders separately so filter pills don't collapse on selection
- NotificationRoutingPanel: rollback optimistic update on save failure
- useSettingsNavigation: add notifications/notification-routing routes
- scripts/install.sh: remove silent dry-run exit 0 on asset failure
- scripts/setup-dev-codesign.sh: remove unconditional -legacy flag
- docs/SUMMARY.md: remove worktree path, fix macOS capitalisation,
remove self-referential deletion note
* chore: apply prettier + cargo fmt + fix useEffect dep warning
Auto-apply formatting changes flagged by the pre-push hook:
- prettier reformatted NotificationCenter.tsx and notificationService.ts
- cargo fmt reformatted all.rs, openhuman/mod.rs, notifications/schemas.rs
- NotificationRoutingPanel: move providers array to module scope so
useEffect dependency array is satisfied without exhaustive-deps warning
* feat(notifications): enhance notification management and permissions
- Added new commands for managing notification preferences, including setting global Do Not Disturb (DND), muting specific accounts, and retrieving current bypass preferences.
- Implemented a notification permission state handler to ensure consistent behavior across different environments.
- Updated the JavaScript shim for notification permissions to handle both Notification and PushManager states, ensuring compatibility with various providers.
- Refactored the WebviewAccountsState to include a new structure for managing notification bypass preferences, improving the overall notification handling logic.
* update agents
* fix(notifications): complete schema + navigation metadata for ingest/settings routes
- app/src/components/settings/hooks/useSettingsNavigation.ts: resolve the
new `/settings/notifications` and `/settings/notification-routing` URLs
to their SettingsRoute values and feed them into breadcrumbs so the new
panels don't silently fall through to `'home'`. Addresses CodeRabbit on
useSettingsNavigation.ts:34.
- src/openhuman/notifications/schemas.rs: add the optional `reason` output
on `notification.ingest` (populated alongside `skipped=true` by the
runtime) and the normalized `settings` output on `notification.settings_set`
so schema-driven clients see the full response shape. Addresses
CodeRabbit on schemas.rs:103 and schemas.rs:217.
- src/core/all.rs: add a `notification` namespace_description so CLI help
covers the new controllers, plus a test assertion. Addresses CodeRabbit
on src/core/all.rs:149.
* fix(notifications): trace DB entry, surface empty update matches, warn on bad scored_at
- Add `tracing::trace!` checkpoints around the `with_connection` DB open
and schema migration so notification-delivery issues are reconstructible
from logs.
- `update_triage` and `mark_read` now inspect `Connection::execute`'s
affected-row count: log a `warn!` when the update matched zero rows
(row deleted between ingest and scoring / client passed a stale id),
`debug!` on the normal path.
- `scored_at` parsing no longer silently drops malformed values — log a
`warn!` with the raw value and parse error before treating the row as
unscored, matching the existing behavior for `received_at`.
Addresses CodeRabbit on store.rs (lines 72, 172, 294).
* fix(webview): respect silent notifications, multi-host CDP fallback, shim idempotency
- webview_accounts/mod.rs: honor the Web Notification `silent` flag.
Previously we only logged it and still called `builder.show()`, so
pages that marked a notification silent still produced an OS toast.
Mirror event still fires so the in-app center updates; only the OS
toast is suppressed. Also picks up a prior cargo-fmt rewrap.
- cdp/target.rs: `browser_ws_url()` now continues the host loop when
`resp.json()` fails instead of early-returning via `?`. A malformed
response from the first host (CDP_HOST) no longer prevents the
`localhost` fallback from being tried.
- webview_accounts/ua_spoof.js: guard the Notification wrapper behind
`window.__OH_NOTIF_SHIM` so repeated evaluations of the script
(Page.addScriptToEvaluateOnNewDocument + frame-level re-injections)
don't stack wrappers onto the same page globals or re-proxy
`Function.prototype.toString`.
Addresses CodeRabbit on webview_accounts/mod.rs:377, cdp/target.rs:33,
and ua_spoof.js:176.
* update agents
* update
---------
Co-authored-by: oxoxDev <nikhil@tinyhumans.ai>
Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>
Co-authored-by: Steven Enamakel <enamakel@tinyhumans.ai>
* feat(skills/core): add read_skill_resource with size + traversal guards (#681)
Introduces `read_skill_resource(skill_id, relative_path)` in the skills
ops module. Used by the new `skills.read_resource` RPC (landed in a
follow-up commit) to let the UI preview files bundled alongside a
SKILL.md without having to shell out to the Node runtime.
Guards rejecting each known attack surface have their own unit test:
- empty skill_id / empty relative_path
- unknown skill
- absolute paths
- `..` traversal escapes (checked after canonicalization against the
skill root, reusing the pattern from the Node exec allowlist)
- directory targets
- symlinked leaves (reject via `symlink_metadata` before open)
- files over the 128 KB cap
- non-UTF-8 content (binary allowlist is text-only)
Happy-path test covers a small text resource under the skill root.
Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
* feat(skills/core): wire skills.read_resource RPC + namespace (#681)
Adds `skills` RPC namespace with `skills.list` and `skills.read_resource`
handlers. `read_resource` delegates to `read_skill_resource` (previous
commit) and surfaces path-traversal / size / encoding errors back to the
caller verbatim so the UI can render the error string as-is.
- `src/openhuman/skills/schemas.rs` (new): controller + schema
definitions, plus unit tests for schema name stability, round-trip of
the minimum `SkillSummary` fields, and controller list/schema length
parity.
- `src/openhuman/skills/mod.rs`: declare `pub mod schemas` and re-export
`all_skills_controller_schemas`, `all_skills_registered_controllers`,
and `skills_schemas`.
- `src/core/all.rs`: register the controllers + schemas and add a
namespace description so the RPC discovery endpoint surfaces it.
Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
* feat(app/api): typed skillsApi client for list + read_resource (#681)
Thin typed wrapper around the `skills.list` and `skills.read_resource`
RPCs added in the previous commit. The client normalises the backend
response shape (bytes + UTF-8 content) and rethrows backend error
strings verbatim so the preview pane can render them unchanged.
Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
* feat(app/ui): SkillResourceTree groups bundled resources by top dir (#681)
Presentational component that takes the `resources: PathBuf[]` from a
loaded Skill and renders it as a grouped list (scripts, assets,
references, etc. based on the first path segment). Selecting a leaf
calls `onSelect(relativePath)` so the parent drawer can drive preview
state.
Stateless — no fetching, no effects. Styling follows the stone/coral
design tokens used across the Skills page.
Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
* feat(app/ui): SkillResourcePreview size-gated viewer + specs (#681)
Presentational component that fetches a single bundled resource via
`skillsApi.readSkillResource`. Backend caps payloads at 128 KB and
either returns UTF-8 text or a plain error string, so the preview pane
has three visual states: loading, error, success.
- On error (e.g. "path escape", ">128KB", "non-UTF-8"), renders the
backend message verbatim in a coral panel.
- On success, renders a monospace pre block with the byte count in the
footer.
- `key={id:path}` on the mount site (in SkillDetailDrawer, next commit)
drives a remount when the selected resource changes — so no
setState-in-effect hack is needed to reset loading state.
Vitest specs cover: loading state, success rendering with byte footer,
error rendering for traversal / oversize / encoding strings, cancelled
fetch guard on unmount.
Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
* feat(app/ui): SkillDetailDrawer right-side detail panel + specs (#681)
Slide-in right-hand drawer that displays frontmatter metadata
(description, version, author, license, tags, allowed_tools) and hosts
SkillResourceTree + SkillResourcePreview. Opened by clicking a skill
card on the Skills page (wired in the next commit).
- Focus management: on mount, focuses the close button via
`window.requestAnimationFrame` and restores the previously focused
element on unmount.
- Esc + backdrop click dismiss.
- Preview pane is conditionally rendered and keyed on
`${skill.id}:${selectedResource}` so changing the selected resource
remounts the previewer (avoids setState-in-effect pattern).
Vitest specs cover: render with frontmatter, resource tree click opens
preview, close button / Esc / backdrop dismiss paths, focus
restoration, empty-resources case.
Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
* feat(app/ui): open SkillDetailDrawer on skill card click (#681)
Wires the Skills page to the new drawer: clicking a skill card sets
`selectedSkill` state, which mounts `SkillDetailDrawer`. Dismissing the
drawer clears the state. Cards gain an explicit "View details"
affordance for discoverability.
Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
* feat(skills/core): add skills.create RPC for scaffolded SKILL.md authoring (#681)
Adds `create_skill` in ops.rs plus the `skills.create` controller + handler
in schemas.rs. Writes a minimal SKILL.md (with optional license/author/tags/
allowed-tools frontmatter) under the selected scope, scaffolds scripts/
references/assets subdirs, and re-discovers the skill to return the parsed
SkillSummary. Legacy scope rejects; Project scope requires the trust marker;
User scope is always allowed when a home directory is available.
Hardened against path traversal the same way read_skill_resource is:
canonicalize the scope root, canonicalize the target dir, reject unless the
target starts with the root. Slug derivation is ASCII-only (collapse whitespace/
-/_ to a single hyphen, drop other chars, trim hyphens, enforce MAX_NAME_LEN).
Tests (hermetic via create_skill_inner):
- user-scope happy path (slug, metadata, SKILL.md on disk, subdirs)
- slug collision rejection
- invalid name (no alphanumerics) rejection
- project-scope without trust marker rejection
- project-scope with trust marker happy path
- legacy-scope rejection
- empty-description rejection
- slugify edge cases
Closes part of #681 (backend scope for create flow).
* feat(skills/core): add skills.install_from_url RPC via npx skills add (#681)
Introduces `install_skill_from_url(url, timeout_secs?)` — a JSON-RPC method
that shells out to `npx --yes skills add <url>` under the managed Node
runtime so the UI can install published SKILL.md packages directly.
Security posture:
- https scheme only (no http, file, ssh, git+https…)
- Rejects `localhost`, `*.localhost`, `*.local`, RFC1918 private IPv4,
loopback, link-local, multicast, broadcast, unspecified, 100.64/10 CGN,
0.0.0.0/8, and IPv6 loopback/unspecified/multicast, fc00::/7 ULA,
fe80::/10 link-local. Explicitly covers 169.254.169.254 cloud metadata.
- Trims + caps URL at 2048 chars; parses with the `url` crate.
- IPv6 brackets stripped from `host_str()` before address parse.
Process posture:
- Reuses `NodeBootstrap` so the managed toolchain resolves first.
- `env_clear()` + explicit PATH injection (bootstrap bin_dir first) + a
narrow safe-env allow-list (HOME, TERM, LANG, LC_ALL, LC_CTYPE, USER,
SHELL, TMPDIR). Matches the npm_exec pattern from #723.
- Default 60s wall-clock timeout, capped at 600s.
- Captures stdout/stderr; returns both on success or failure.
- Diff-based `new_skills`: snapshots discovered skills pre-install and
reports slugs that appear post-install.
Surface:
- JSON-RPC: `openhuman.skills_install_from_url`
params: { url: string, timeout_secs?: number }
result: { url, stdout, stderr, new_skills[] }
- Wired into `all_skills_controller_schemas()` and
`all_skills_registered_controllers()`.
Tests (5 new unit tests, all pass — 51/51 in skills::):
- validate_install_url_accepts_public_https
- validate_install_url_rejects_non_https_scheme (http, file, ftp, ssh,
git+https, javascript)
- validate_install_url_rejects_empty_and_oversized
- validate_install_url_rejects_private_and_loopback (20 URLs inc. CGN,
cloud metadata, IPv6 ULA/link-local/loopback/multicast)
- validate_install_url_rejects_malformed (missing scheme, empty host,
non-https scheme, unparseable bracketed host)
Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
* feat(app/api): skillsApi.createSkill + installSkillFromUrl wrappers (#681)
Adds typed frontend wrappers for the two new skill-authoring RPC methods:
- `skillsApi.createSkill(input)` — scaffolds a new SKILL.md skill via
`openhuman.skills_create`. Accepts camelCase `allowedTools` and rekeys
it to the `allowed-tools` spelling the SKILL.md frontmatter convention
expects, matching `SkillsCreateParams` in `src/openhuman/skills/schemas.rs`.
Optional fields are only sent when explicitly provided so the Rust
`#[serde(default)]` defaults apply cleanly.
- `skillsApi.installSkillFromUrl(input)` — installs a published skill
package via `openhuman.skills_install_from_url`. Accepts camelCase
`timeoutSecs` and rekeys it to `timeout_secs`. Normalizes the response
(snake_case `new_skills` -> camelCase `newSkills`, missing list -> []).
Both wrappers reuse the existing `unwrapEnvelope` helper so they
tolerate either a bare RPC payload or the `{ data: … }` envelope some
transports emit.
Adds `CreateSkillInput`, `InstallSkillFromUrlInput`, and
`InstallSkillFromUrlResult` type exports for downstream modal components.
Tests (vitest, 6 new specs, all pass):
- createSkill forwards inputs and rekeys allowedTools
- createSkill omits optional fields when absent
- createSkill unwraps envelope responses
- installSkillFromUrl forwards url and rekeys timeoutSecs
- installSkillFromUrl omits timeout_secs + defaults newSkills to []
- installSkillFromUrl unwraps envelope responses
Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
* feat(app/ui): CreateSkillModal for scaffolding SKILL.md skills (#681)
Adds a centered white modal that scaffolds a new SKILL.md skill via
`skillsApi.createSkill`, matching the settings-modal design rules
(520px desktop, 16px radius, backdrop+blur, Escape/click-out to close,
focus capture).
Form fields mirror the Rust `SkillsCreateParams` schema:
- name (required) — display name, also slugified into the on-disk
directory; a live slug preview surfaces what will hit disk
- description (required) — short prose; written as the
`description:` field in the generated YAML frontmatter
- scope (user | project radio) — `legacy` is hidden because that
layout is read-only and being phased out
- license (optional) — free-form SPDX-style string
- author (optional)
- tags (optional, CSV) — normalised client-side; empty entries dropped
- allowedTools (optional, CSV) — rekeyed to `allowed-tools` on the
JSON-RPC wire by `skillsApi.createSkill`
The slug preview mirrors `slugify_skill_name` on the Rust side
(lowercase ASCII alnum + `-`, collapse repeats, trim edge hyphens) so
the user sees what the Rust slugifier will produce; the Rust side stays
authoritative when the skill is persisted.
On success `onCreated(skill)` fires with the freshly-discovered
`SkillSummary`, letting the parent grid insert the new row without a
full refetch. On failure the Rust error string is surfaced verbatim in
a coral-styled alert and the submit button re-enables.
Vitest specs cover: required-field rendering, live slug preview,
submit-disabled gating, Escape close, wire-format rekey of
`allowedTools` → `'allowed-tools'`, `onCreated` dispatch, and
error-banner recovery.
Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
* feat(app/ui): InstallSkillDialog for npx skills add <url> (#681)
Adds a centered white modal that installs a published skill package
via `skillsApi.installSkillFromUrl`. The Rust side shells out to
`npx --yes skills add <url>` under the managed Node toolchain, with
an allow-list on the URL (https only, no private/loopback/link-local/
multicast/cloud-metadata hosts) and a wall-clock timeout (default 60s,
max 600s).
UI contract:
- Single URL input plus optional timeout in seconds.
- Client-side `isLikelyValidUrl` fails fast on non-https URLs so the
user doesn't pay a round-trip for shape errors the Rust side would
reject anyway; the Rust side remains authoritative.
- Timeout field validates `1 <= n <= 600` client-side to mirror the
server-side clamp range.
- While the RPC is in flight we render a spinner with "Running
`npx skills add`…" copy and disable close / backdrop dismiss so we
don't orphan the subprocess.
- On success we surface the list of `newSkills` (ids that appeared
post-install) plus captured stdout/stderr panes inside collapsible
<details> elements, then hand the full result back to the caller
via `onInstalled` so the parent can refetch the skills list and
auto-select the new row.
- On failure the Rust error string is rendered verbatim in a coral
alert and the submit button re-enables.
Vitest specs cover: required-field rendering, URL shape gating (empty,
malformed, http://, https://), timeout range validation, `timeoutSecs`
forwarding on submit, success panel with newSkills rendering, blank
timeout omitted from payload, and error-banner recovery.
Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
* feat(app/ui): wire New skill + Install from URL into Skills page (#681)
Adds a header row on the Skills page with two buttons:
- **New skill** → opens `CreateSkillModal`
- **Install from URL** → opens `InstallSkillDialog`
Extracts the existing `listSkills` effect into a reusable
`refreshDiscoveredSkills` helper so both new flows can reconcile their
results against the freshly-discovered `SkillSummary` rows rather than
relying on the optimistic payload from the RPC alone.
Create flow:
- Optimistically appends the returned `SkillSummary` to
`discoveredSkills` (dedupe by id).
- Auto-opens the detail drawer for the new skill so the user lands in
context — matches the install flow's UX.
- Follows up with `refreshDiscoveredSkills()` so version/author/
warnings picked up by the Rust discoverer end up in state too.
Install flow:
- Always refreshes the list (the install can add multiple skills if
the package declares several).
- Auto-opens the detail drawer for the first newly-installed skill
when at least one id is reported back; otherwise leaves the grid in
its refreshed state.
Both buttons sit in a flush `max-w-lg` header above the existing
search bar, styled consistent with `UnifiedSkillCard` CTAs — ocean
primary for "New skill" (positive action), neutral stone for "Install
from URL" (secondary).
Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
* refactor(skills/core): direct SKILL.md fetch replaces npx skills add (#681)
Installer no longer shells out to the vercel-labs/skills CLI. It now fetches
SKILL.md over HTTPS, validates YAML frontmatter, and writes into the user's
skills dir. Size cap (1 MiB), timeout clamp (1-600s), GitHub blob->raw URL
normalization, and path-traversal guards are covered by unit tests.
Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
* refactor(app/ui): install dialog copy + categorized errors for direct fetch (#681)
Dialog subtitle, helper text, and in-flight indicator reflect the new direct
SKILL.md fetch flow. Errors from the core are categorized into friendly titles
(URL rejected, too large, timeout, parse failure, already installed, write
failed) with the raw backend message tucked under a details disclosure.
Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
* test(app/ui): dialog specs cover direct-fetch fixtures + error categorization (#681)
Fixtures updated to raw GitHub SKILL.md URLs. New cases assert the
categorization helper surfaces the right title for invalid SKILL.md, unsupported
URL form, and unknown backend errors (raw text hidden under details).
Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
* fix(skills/core): install_from_url writes to user scope (#681)
Project scope (`<ws>/.openhuman/skills/`) is gated on a `<ws>/.openhuman/trust`
marker that the workspace rarely has, so freshly-installed skills were
invisible to `skills.list` until the user opted the workspace into trust.
Route installs to `~/.openhuman/skills/<slug>` — the user-scope root that
`discover_skills` always scans — so "Install from URL" surfaces the new
skill immediately.
Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
* docs(skills): align install_from_url docs with direct-fetch impl (#681)
`install_from_url` stopped shelling out to `npx --yes skills add <url>` when
it was rewritten to fetch SKILL.md over HTTPS directly, but schema
descriptions and SDK wrappers still described the old subprocess flow. Fix
the module-level rustdoc, the JSON-RPC schema `description`/`comment`
fields, and the TS client wrapper doc comments so the surface documents
what actually runs.
Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
* fix(skills/core): DNS-to-private-IP SSRF guard + install rollback (#681)
Two fixes surfaced by CodeRabbit review on PR #740:
* `validate_install_url` only inspected literal-IP hosts, so a
public-looking hostname like `evil.example.com` with an A record
pointing at `127.0.0.1` / `169.254.x` / etc. would still be handed to
`reqwest`. Resolve the host via `tokio::net::lookup_host` before the
GET and reject if any returned address falls in loopback / private /
link-local / multicast / unspecified ranges. Document the remaining
DNS-rebinding gap (pinning to a `SocketAddr` + custom reqwest
resolver is tracked separately).
* If `std::fs::write` or `std::fs::rename` fails after `create_dir_all`
succeeded, the empty/partial target directory used to survive and
permanently block retries under the same slug. Wrap the write+rename
in a rollback that removes the temp file + the just-created directory
on failure (best-effort; cleanup errors are logged and the original
write error is surfaced).
Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
* style(skills): cargo fmt break long Host::Ipv6 conditional (#681)
CI's cargo fmt (stable) rewraps the long `.map(..).unwrap_or(false)` chain
that passed local fmt. Apply the break so the pre-push hook and the
upstream lint job agree.
Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
---------
Co-authored-by: Claude Opus 4.7 <noreply@anthropic.com>
* wip(notifications): core module skeleton + controller registration
Phase 7 PR #714 work-in-progress. Shipped:
- src/openhuman/webview_notifications/ — mod, types, dispatch, bus, schemas
- pub mod declaration in src/openhuman/mod.rs
- controllers entry in src/core/all.rs
Remaining: schemas line in all.rs, Tauri shell edits (OpenHuman: prefix,
feature flag gate, click event emit), new shell module for feature flag
state + commands, frontend app/src/lib/webviewNotifications/ IPC wrapper,
Redux click handler.
* feat(notifications): register webview_notifications schemas in core registry
Adds the schemas line next to the already-registered controllers entry so
the domain participates in declared-schema validation. v1 controller list
is empty (settings live shell-side), but the wiring is in place for
future additions.
* feat(notifications): add OpenHuman: prefix, feature flag, and click-routing event
Updates the CEF notification hook in webview_accounts to:
- Prefix OS toast titles with "OpenHuman:" so they visually disambiguate
from natively installed apps (Slack, Gmail, Discord desktop) firing the
same DM twice.
- Gate delivery on a new shell-side feature flag (off by default).
- Mirror each fire to the React frontend via a `webview-notification:fired`
Tauri event carrying {account_id, provider, title, body, tag}, so the
UI can route click-to-focus back to the originating webview.
Adds a new notification_settings shell module holding the runtime toggle
as an AtomicBool (lock-free read from the CEF callback thread) plus
notification_settings_{get,set} Tauri commands for the settings UI to
flip the flag. State lives shell-side rather than in the core sidecar so
the toggle doesn't require a JSON-RPC round-trip.
* feat(notifications): frontend IPC wrapper + Redux click routing
Mirrors the Rust-side `webview-notification:fired` Tauri event into
Redux so the UI can:
- bump an unread badge on the originating account (sidebar surface
reads `accounts.unread[accountId]`)
- route a subsequent click intent back to the right embedded webview
via `focusAccountFromNotification`, which sets `activeAccountId`
and clears the unread counter in one action
Plumbing:
- `app/src/lib/webviewNotifications/` — typed subscribe/unsubscribe,
idempotent `started` guard mirroring `webviewAccountService.ts`,
`handleNotificationClick(accountId)` as the public click entrypoint
so in-app toast UI or a future OS-notification click hook share one
Redux intent
- `accountsSlice`: `noteWebviewNotificationFired` and
`focusAccountFromNotification` reducers (both no-op for unknown
account ids — guards against stale payloads from a closed webview)
- `App.tsx`: start the service at boot, right next to the existing
`startWebviewAccountService()` call
Tests:
- `accountsSlice.webviewNotifications.test.ts` — reducer behavior
- `service.test.ts` — fired dispatches + click focuses via real store
Also: `cargo fmt` noise fixups on `src/core/all.rs` and
`src/openhuman/webview_notifications/mod.rs` so the branch passes
`cargo fmt --check` in CI.
---------
Co-authored-by: Jwalin Shah <jshah1331@gmail.com>
* feat(memory): phase 1 memory tree - multi-source ingestion & canonical chunks (#707)
Adds an isolated memory tree layer under src/openhuman/memory/tree/
implementing Phase 1 of the new memory architecture (umbrella #711).
Zero edits to existing memory/*.rs files - the new layer coexists
with the legacy TinyHumans-backed client.
- Source adapters: chat / email / document -> canonical Markdown
- Token-bounded chunker with deterministic SHA-256 chunk IDs
- SQLite persistence at <workspace>/memory_tree/chunks.db with full
provenance metadata (source_kind, source_id, owner, timestamps,
tags, time_range) and back-pointer to raw source
- Unified JSON-RPC ingest (dispatches on source_kind + JSON payload):
openhuman.memory_tree_ingest, _list_chunks, _get_chunk
- DataSource enum covering the 8 providers from m.excalidraw step 1
(Discord/Telegram/Whatsapp/Gmail/OtherEmail/Notion/MeetingNotes/DriveDocs)
- ~40 unit tests (chunk ID stability, UTF-8-safe splitting,
canonicalisation idempotence, store round-trip, filter behavior)
Additive only: new tables in a new DB file, new JSON-RPC namespace,
no existing behavior changes. Feeds #708 (scoring), #709 (summary
trees), #710 (query tools).
Closes#707. Parent: #711.
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
* feat(memory): enhance memory tree functionality and tests
- Added support for "memory_tree" namespace description in `namespace_description`.
- Implemented clamping for zero token budget in `chunk_markdown` to prevent empty leading chunks.
- Introduced detailed logging for document ingestion, including title length.
- Updated output schemas in `schemas.rs` for improved clarity.
- Enhanced chunk listing with clamping limits and ordering by sequence in `list_chunks`.
- Normalized source references in canonicalization functions to drop blank values.
- Added comprehensive tests for new features and edge cases in chunking and canonicalization.
These changes improve the robustness and usability of the memory tree layer, aligning with ongoing development efforts for Phase 1 of the memory architecture.
* fix(memory): address follow-up CodeRabbit comments
---------
Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
Co-authored-by: Steven Enamakel <enamakel@tinyhumans.ai>
* feat(conversations): implement thread management features including creation and deletion
- Added functionality to create new conversation threads with unique IDs and titles based on the current date and time.
- Introduced a deleteThread action to remove existing threads, updating the selected thread accordingly.
- Enhanced the UI to display threads in a sidebar, allowing users to select and delete threads easily.
- Updated the Conversations component to handle thread loading and selection more efficiently, ensuring a smoother user experience.
Also updated the OpenHuman package version to 0.52.15 in Cargo.lock files.
* refactor(conversations): rename createThreadLocal to createNewThread and streamline thread creation logic
- Updated the function name from `createThreadLocal` to `createNewThread` for clarity and consistency.
- Simplified the thread creation process by removing the manual ID and title generation, leveraging the new API method for automatic thread creation.
- Adjusted the Conversations component to utilize the new `handleCreateNewThread` function, enhancing readability and maintainability.
- Removed unused thread ID and title generation functions to clean up the codebase.
This refactor improves the overall structure and clarity of the thread management functionality.
* refactor(memory): remove deprecated conversation thread management functions
- Eliminated unused functions related to listing, creating, updating, appending, and deleting conversation threads in memory operations.
- This cleanup enhances code maintainability and reduces complexity in the memory module.
- The refactor focuses on streamlining the conversation management logic, aligning with recent changes in the thread handling API.
* refactor(api): update thread API method names and remove deprecated functions
- Renamed thread-related API methods to align with the new naming convention, improving clarity and consistency.
- Removed deprecated functions related to thread creation, streamlining the API and enhancing maintainability.
- Adjusted the implementation of existing methods to reflect the updated API structure, ensuring proper functionality.
* refactor(thread): simplify thread state management and remove unused properties
- Streamlined the thread state by removing the lastViewedAt property and related logic, enhancing clarity in unread message counting.
- Updated the BottomTabBar component to reflect the new unread count logic, which now simply returns the length of threads.
- Removed the setLastViewed action from the Conversations component, further simplifying the thread management logic.
- Introduced a new deleteThread action to handle thread deletion, ensuring proper state updates and selection handling.
- Overall, these changes improve maintainability and reduce complexity in the thread management system.
* style(threads): apply cargo fmt
* refactor(tabbar): remove conversations unread badge
* update(Cargo.lock): bump OpenHuman package version to 0.52.15
* test(threadApi): update RPC method names to threads namespace
* refactor(conversations): update model ID for chat functionality
- Changed the model ID used in the chatSend function from `agentic-v1` to `reasoning-v1`, clarifying the purpose of each model.
- Added comments to explain the distinction between the reasoning model and the agentic model, enhancing code readability and maintainability.
* refactor(composio): restructure toolkit metadata handling and onboarding steps
- Removed the old `toolkitMeta.ts` file and replaced it with a new `toolkitMeta.tsx` file that includes updated metadata handling for Composio toolkits, enhancing the integration with React components.
- Updated the `ComposioConnectModal` to directly render icons without additional markup, streamlining the component structure.
- Modified the `Skills` page to utilize the new icon rendering method, improving consistency across the application.
- Enhanced the onboarding process by introducing a new `ContextGatheringStep` component, which gathers user context from connected integrations, improving the onboarding experience.
- Updated the `SkillsStep` to reflect changes in toolkit connection handling and display, ensuring a smoother user interaction during onboarding.
* feat(apify): introduce Apify integration tools for actor execution and status retrieval
- Added new tools for running Apify actors and fetching their run statuses, enhancing automation capabilities.
- Updated the integration schema to include an `apify` toggle for user configuration, allowing for flexible integration management.
- Enhanced the onboarding experience by modifying the SkillsStep to focus on Gmail integration, streamlining user interactions.
- Improved documentation and comments for clarity on the new Apify functionalities and their usage.
* feat(learning): add LinkedIn enrichment module and schemas
- Introduced a new `linkedin_enrichment` module for enriching user profiles by scraping LinkedIn data from Gmail.
- Implemented the `run_linkedin_enrichment` function to handle the enrichment pipeline, including Gmail search, scraping via Apify, and data persistence.
- Added controller schemas for the learning domain, enabling integration with the existing controller framework.
- Updated the `all.rs` file to register the new learning controllers and schemas, enhancing the overall functionality of the learning system.
* feat(linkedin): implement PROFILE.md generation for LinkedIn enrichment
- Added functionality to generate a PROFILE.md file from scraped LinkedIn data, summarizing user profiles for agent context.
- Updated the `run_linkedin_enrichment` function to write PROFILE.md to the workspace, enhancing data persistence.
- Introduced helper functions for rendering and summarizing LinkedIn profiles, improving the overall enrichment process.
- Ensured minimal PROFILE.md creation even when scraping fails, maintaining essential user context.
* feat(onboarding): enhance ContextGatheringStep for LinkedIn enrichment pipeline
- Updated the ContextGatheringStep to integrate a new pipeline for LinkedIn enrichment, replacing the previous Gmail profile fetching stages.
- Implemented a progress animation and logging for the enrichment process, improving user feedback during data retrieval.
- Refactored stage definitions to align with the new pipeline structure, enhancing clarity and maintainability.
- Introduced error handling and status updates for each stage of the enrichment process, ensuring robust user experience.
* feat(instructions): refactor tool instruction generation for clarity and flexibility
- Introduced helper functions `tool_instructions_preamble` and `append_tool_entry` to streamline the construction of tool instructions.
- Updated `build_tool_instructions` to utilize the new helper functions, improving code readability and maintainability.
- Added `build_tool_instructions_filtered` to allow for generating instructions from a filtered list of tools, enhancing flexibility in tool usage.
- Adjusted the startup process to use the filtered instructions, ensuring only relevant tools are included in the system prompt.
* refactor(toolkitMeta): simplify component structure and improve readability
- Refactored the `BrandIcon` component to streamline its props definition, enhancing code clarity.
- Consolidated SVG path definitions in various icons for better readability and maintainability.
- Updated the `ContextGatheringStep` to simplify the RPC call syntax, improving code conciseness.
- Enhanced logging in the LinkedIn enrichment process for clearer tracking of Gmail searches and scraping stages.
* fix: address PR review — USER.md→PROFILE.md consistency, Composio tool filtering, and quality fixes
- Replace USER.md with PROFILE.md across all prompt paths: channels_prompt.rs,
subconscious/prompt.rs, workspace/ops.rs bootstrap, and channel tests
- Remove Composio tool description from main agent system prompt (tool_descs)
so skills_agent is the only agent that sees Skill-category tools
- Add "learning" namespace description for CLI help discovery
- Fix react-hooks/set-state-in-effect: wrap synchronous setState in
queueMicrotask in ContextGatheringStep
- Derive SkillsStep displayToolkits from backend allowlist with error/retry UI
- Add KNOWN_COMPOSIO_TOOLKITS alternate slug variants (google_calendar, etc.)
- Add namespaced debug logging to onboarding handlers and pipeline
- Deduplicate MemoryClient creation in linkedin_enrichment persist functions
* fix: use setTimeout instead of queueMicrotask for ESLint compatibility
* refactor(onboarding): streamline debug logging in handleContextNext function
- Consolidated debug logging in the handleContextNext function to improve clarity and reduce verbosity.
- Removed unnecessary line breaks for a more concise code structure.
* refactor(linkedin): enhance enrichment pipeline with structured stage results
- Introduced a new `EnrichmentStage` struct to capture detailed results for each stage of the LinkedIn enrichment process.
- Updated the `LinkedInEnrichmentResult` to include a vector of stages, allowing for structured reporting of success, failure, and skipped stages.
- Improved error handling and logging throughout the enrichment pipeline, ensuring better traceability of issues during execution.
- Adjusted the API response to include stage results, enhancing the frontend's ability to display detailed enrichment outcomes.
* chore(workflows): update macOS E2E test configuration and comment out Linux E2E job
- Modified the description and default values in the macOS E2E test input options for clarity.
- Commented out the entire Linux E2E job configuration to prevent execution while maintaining the setup for future use.
* feat(tests): add comprehensive unit tests for hooks and memory context
- Introduced a suite of tests for the `fire_hooks` function, ensuring that all hooks are dispatched even if one fails, enhancing reliability in the hook execution flow.
- Added tests for the `sanitize_tool_output` function to validate the correct mapping of success and failure messages for various tool outputs.
- Implemented a mock memory structure to facilitate testing of memory context building, ensuring that working memory is prioritized and deduplication occurs correctly.
- Enhanced the `build_memory_context` function tests to verify filtering and truncation of memory entries, improving the robustness of memory management in the system.
- Overall, these tests aim to strengthen the codebase by ensuring that critical functionalities related to hooks and memory context are thoroughly validated.
* feat(tests): enhance unit tests for provider alias resolution and prompt options
- Updated the `provider_alias_and_route_selection_round_trip` test to dynamically resolve the first provider from the registry, ensuring accurate alias resolution.
- Added new tests for `DumpPromptOptions` and `ComposioStubTools`, validating default settings and expected tool names.
- Introduced tests for rendering main agent dumps, ensuring tool instructions and skill counts are correctly included in the output.
- Enhanced prompt handling tests to cover cache boundary extraction and subagent render options, improving overall test coverage and reliability.
* feat(tests): enhance error handling and formatting in unit tests
- Added new tests for `AgentError` variants to validate string formatting and error recovery from `anyhow`.
- Improved formatting consistency in existing tests for better readability.
- Enhanced the `sanitize_tool_output` test to ensure accurate mapping of success and failure messages.
- Updated memory loader tests to enforce minimum limits and budget constraints, ensuring robust memory management.
- Overall, these changes aim to strengthen the test suite by improving coverage and clarity in error handling scenarios.
* feat(tests): add unit tests for tool filtering and subagent dump rendering
- Introduced new tests to validate the filtering of tools based on named scopes and disallowed tools, ensuring correct tool selection in debug dumps.
- Added tests for rendering subagent dumps, including handling file prompt fallbacks and missing files without panicking.
- Enhanced the workspace prompt handling to prefer custom prompt locations, improving the flexibility and reliability of agent prompt rendering.
- Overall, these additions strengthen the test suite by covering critical functionalities related to tool filtering and prompt rendering.
* feat(tests): add comprehensive unit tests for memory loader and multimodal helpers
- Introduced new tests for the memory loader to validate behavior when the header exceeds budget and when recall fails, ensuring robust memory management.
- Added tests for multimodal helpers, covering image marker counting, payload extraction, and MIME type normalization, enhancing the reliability of multimodal interactions.
- Overall, these additions strengthen the test suite by improving coverage and ensuring correct functionality in memory handling and multimodal processing.
* feat(tests): add unit tests for tool execution and agent behavior
- Introduced new tests for the `run_tool_call_loop` function, validating the rejection of vision markers for non-vision providers and ensuring correct streaming of final text chunks.
- Added tests to verify that CLI-only tools are blocked in prompt mode and that native tool results are persisted as tool messages.
- Enhanced the `Agent` class with tests for error handling and event publishing during single runs, ensuring robust agent behavior in various scenarios.
- Overall, these additions strengthen the test suite by improving coverage and reliability in tool execution and agent interactions.
* feat(tests): enhance tool execution and agent behavior tests
- Added new tests for the `run_tool_call_loop` function, including scenarios for auto-approving supervised tools on non-CLI channels and handling unknown tools with default max iterations.
- Introduced `ErrorResultTool` and `FailingTool` to simulate error conditions during tool execution, improving coverage of error handling in the agent.
- Updated the `ScriptedProvider` to return results wrapped in `anyhow::Result`, ensuring consistent error handling across test cases.
- Overall, these enhancements strengthen the test suite by validating tool execution paths and agent behavior under various conditions.
* refactor(tests): improve test readability and structure
- Enhanced formatting in various test cases for better clarity and consistency, including the use of line breaks and indentation.
- Updated assertions to improve readability by aligning them with Rust's idiomatic style.
- Overall, these changes aim to strengthen the test suite by making it more maintainable and easier to understand.
* docs(agent): enhance module documentation for agent domain
- Added comprehensive documentation to the `mod.rs` file, detailing the agent domain's purpose, key components, and their functionalities.
- Improved clarity on how LLMs interact with the system, manage conversation history, and handle autonomous behaviors.
- This update aims to enhance understanding and maintainability of the agent domain within the OpenHuman project.
* docs(agent): improve documentation and formatting across multiple files
- Enhanced comments and documentation in `dispatcher.rs`, `error.rs`, `hooks.rs`, and `harness/mod.rs` for better clarity and consistency.
- Adjusted formatting in the `TurnContext` and `ToolCallRecord` structs to improve readability and understanding of their purpose and functionality.
- Overall, these changes aim to strengthen the documentation and maintainability of the agent domain within the OpenHuman project.
* feat(tests): add comprehensive tests for memory loader and agent behavior
- Introduced new tests for the `DefaultMemoryLoader`, validating error propagation during primary recall failures and ensuring correct context emission when working memory is present.
- Added tests to verify behavior when the working memory section exceeds budget constraints, enhancing memory management robustness.
- Overall, these additions strengthen the test suite by improving coverage and reliability in memory handling and agent interactions.
* refactor(tests): improve formatting and readability in memory loader tests
- Reformatted the `load_context` calls in memory loader tests for better readability by chaining method calls.
- Enhanced documentation comments in the `pformat.rs` file to clarify the purpose and functionality of functions.
- Improved consistency in spacing and formatting across various sections of the codebase, including the `interrupt.rs` and `builder.rs` files.
- Overall, these changes aim to enhance code clarity and maintainability within the test suite and related modules.
* feat(tests): add new tests for self-healing interceptor and local AI provider
- Introduced tests to validate the detection of missing commands in the `SelfHealingInterceptor`, ensuring proper handling of recognized and unrecognized patterns.
- Added tests for the `ensure_polyfill_dir` method to confirm directory creation and path exposure.
- Enhanced local AI provider tests to verify correct behavior when the service is ready and the appropriate tier is set, as well as ensuring local metadata is utilized during provider resolution.
- Overall, these additions strengthen the test suite by improving coverage and reliability in self-healing and local AI functionalities.
* refactor(tests): enhance test structure and external ID handling in escalation tests
- Updated the `envelope` function to accept an `external_id` parameter, improving flexibility in test scenarios.
- Modified various test cases to utilize specific external IDs, enhancing clarity and ensuring accurate event assertions.
- Introduced a mutex lock in local AI tests to prevent race conditions, ensuring reliable test execution.
- Overall, these changes improve the robustness and maintainability of the test suite for escalation and local AI functionalities.
* refactor(tests): remove redundant test modules and improve test organization
- Eliminated unused test modules from `hooks.rs`, `memory_loader.rs`, `fork_context.rs`, `interrupt.rs`, and `parse.rs` to streamline the codebase.
- Enhanced overall test organization by consolidating relevant tests into appropriate files, improving maintainability and readability.
- These changes aim to simplify the test structure and focus on active test cases, ensuring a cleaner and more efficient testing environment.
* refactor(tests): improve test formatting and readability
- Reformatted assertions in multiple test cases for better readability by aligning them with Rust's idiomatic style.
- Enhanced the structure of test cases by using line breaks and consistent indentation, improving overall clarity.
- These changes aim to strengthen the test suite by making it more maintainable and easier to understand.
* refactor(api): improve string containment check and formatting in transcript handling
- Updated the `key_bytes_from_string` function to use a more concise containment check for special characters.
- Changed the message writing in the `write_transcript` function to utilize `writeln!` for better formatting.
- Enhanced the condition in `latest_in_dir` to use `is_none_or` for improved readability and clarity.
- These changes aim to streamline code and enhance maintainability across the API and transcript handling modules.
* refactor(code): streamline function implementations and improve readability
- Removed unnecessary whitespace in `run_voice_server_command` for cleaner code.
- Simplified directory search logic in `bundled_openclaw_prompts_dir` by using `find` instead of a loop.
- Updated `request_accessibility_access` to use direct references for keys and values, enhancing clarity.
- Improved documentation formatting in `mod.rs` and `types.rs` for better consistency.
- Refactored `Config` initialization in `load.rs` to use struct update syntax for clarity.
- Added `#[allow(clippy::too_many_arguments)]` annotations in multiple functions to address linter warnings.
- Enhanced type definitions and function signatures for better type safety and readability in various modules.
- Overall, these changes aim to improve code maintainability and readability across the project.
* chore(ci): update typecheck workflow and pre-push hooks to include clippy checks
- Modified the GitHub Actions workflow to run clippy with warnings treated as errors for the `openhuman` package.
- Enhanced the pre-push hook to include clippy checks, ensuring code quality before pushing changes.
- Updated package.json to define a new script for running clippy, integrating it into the format check process.
- These changes aim to improve code quality and maintainability by enforcing stricter linting rules.
* refactor(api): simplify condition in key_bytes_from_string function
- Streamlined the condition in the `key_bytes_from_string` function to improve readability by consolidating the if statement into a single line.
- This change enhances code clarity while maintaining the original functionality of the key validation process.
* chore(package): update format:check script to remove clippy integration
- Modified the `format:check` script in `package.json` to exclude the clippy check, streamlining the formatting process.
- This change simplifies the formatting workflow while maintaining the integrity of Rust formatting checks.
* refactor(core): enhance documentation and structure in core modules
- Improved documentation across various core functions, including `build_registered_controllers`, `run_from_cli_args`, and `dispatch`, to clarify their purpose and usage.
- Streamlined comments to provide clearer guidance on the flow of operations and error handling.
- Enhanced the structure of the `EventBus` and `NativeRegistry` to improve readability and maintainability.
- Overall, these changes aim to improve code clarity and facilitate easier navigation and understanding of the core components.
* refactor(core): reorganize imports in engine.rs for clarity
- Adjusted the import statements in `engine.rs` to improve organization and readability.
- Moved the macOS-specific import of `validate_focused_target` to a more appropriate location and ensured consistent ordering of imports.
- These changes aim to enhance code clarity and maintainability within the core module.
* refactor(core): enhance WebChannelEvent structure and documentation
- Introduced a new `WebChannelEvent` struct to standardize event payloads for chat-related activities, including fields for event name, client ID, thread ID, request ID, and optional response details.
- Improved documentation for the `attach_socketio` function, clarifying its role in setting up Socket.IO event handlers and the associated chat logic.
- Removed unused structs and streamlined the event handling process to improve code clarity and maintainability across the core module.
* refactor(core): streamline Socket.IO event handlers for clarity and consistency
- Refactored the Socket.IO event handlers in `attach_socketio` to improve readability by standardizing the formatting and structure of the code.
- Enhanced the organization of the event handling logic for `rpc:request`, `chat:start`, and `chat:cancel` events, making it easier to follow the flow of operations.
- These changes aim to improve code maintainability and facilitate easier navigation within the Socket.IO integration.
* feat(core): add new structs for Socket RPC and chat events
- Introduced `SocketRpcRequest`, `ChatStartPayload`, and `ChatCancelPayload` structs to facilitate handling of Socket.IO events related to chat functionality.
- These additions enhance the structure and clarity of the event payloads, improving the maintainability of the Socket.IO integration.
* refactor(core): remove unused json_type_name function from socketio.rs
- Eliminated the `json_type_name` function from `socketio.rs` as it was not utilized in the current codebase.
- This change helps to clean up the code and improve maintainability by removing unnecessary functions.
* chore(ci): update clippy command in typecheck workflow
- Modified the clippy command in the GitHub Actions workflow to remove the `-D warnings` flag for the `openhuman` package, allowing warnings to be displayed without failing the build.
- This change aims to improve the development experience by providing more flexibility during code analysis while still encouraging code quality.
* chore(husky): remove clippy check from pre-push hook
- Eliminated the clippy command from the pre-push hook to streamline the pre-push checks.
- Updated the failure message to reflect the removal of clippy, focusing on format, lint, TypeScript, and Rust errors only.
- This change simplifies the pre-push process while maintaining essential checks for code quality.
* refactor(tests): add macOS-specific imports for enhanced test coverage
- Introduced conditional imports for macOS in the tests module of `engine.rs` to support platform-specific functionality.
- This change improves the test setup for macOS environments, ensuring compatibility and enhancing overall test coverage.
* refactor(tests): update tool call execution in test cases
- Modified the `execute_tool_call` method calls in multiple test cases to include a second parameter, improving the accuracy of the tests.
- This change ensures that the tests reflect the latest method signature and enhances the reliability of the test outcomes.
* 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.
