0
Fork 0
mirror of https://github.com/zeronsh/comet.git synced 2026-11-16 18:57:19 +00:00
Commit graph

22 commits

Author SHA1 Message Date
Wing
3fc34ad298 Windows CI builds the app as its package does; the beta scripts say what engine they take
windows.yml builds `-p zeron` and then runs package-windows.ps1, which
builds it again with LUAU_CXXFLAGS=-DNDEBUG: Luau and all that links
mlua were built twice. The step takes the same flag. And the beta
scripts' usage says the engine they're given must be built with it, as
the check now holds: a stable release's engine from before isn't.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Co-authored-by: zeronsh[bot] <346184242+zeronsh[bot]@users.noreply.github.com>
2026-11-11 11:23:56 -07:00
Wing
3adca33221 Release engines run Luau without its asserts, and each package checks it
The engine links Luau (mlua's luau0-src: visuals, plugin services) and
was built from the root, where nothing sets LUAU_CXXFLAGS: its Luau kept
its asserts, about a fifth of script time. LUAU_CXXFLAGS=-DNDEBUG now
goes on the builds of a release's engine, not a root .cargo/config.toml,
so test and development builds keep them:

- zgx-beta.yml: each job's "the engine, from this commit" step (macOS,
  Linux, Windows' whole zeron.exe).
- release.yml's engines, which the packaging scripts build themselves:
  package-linux.sh's release build, package-macos.sh, package-windows.ps1
  without -BetaVersion (so a local package is right too).

Each package refuses an engine with them. The engine has no zgx-script,
so not the app's warning; instead what LUAU_ASSERT keeps when asserts
are on (Luau/Common.h: #expr, __FILE__): each Luau source file's path,
VM/src/l*.cpp, either separator. The workflow's engine build, exactly,
here: 36 such paths without the flag, none with it (no luau0-src path at
all); the check fails the first and passes the second. A debug package
(package-linux.sh PROFILE=debug) is left alone: luau0-src turns asserts
on in any debug build.

Co-authored-by: zeronsh[bot] <346184242+zeronsh[bot]@users.noreply.github.com>

On stable-zgx (cherry-picked from d1bf8d327): the engine steps are
zgx-build.yml's, which release.yml's stable and zgx-beta.yml's beta both
call, so the flag goes there, and zgx-beta.yml is stable's as it was;
release.yml's old-app jobs build their engines in the packaging scripts.
package-zgx-beta.sh is package-zgx-macos.sh, and Windows' engine for the
zgx app is -ZgxEngine.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Co-authored-by: zeronsh[bot] <346184242+zeronsh[bot]@users.noreply.github.com>
2026-11-11 11:23:29 -07:00
Wing
3f95513e32 Merge zeron/beta-luau-ndebug into zeron/stable-zgx: Luau's NDEBUG for every zgx package
The conflicts are stable-zgx's renames on the same lines (BETA_VERSION
to ZGX_VERSION, $BetaVersion/$BetaEngine to $ZgxVersion/$ZgxEngine,
package-zgx-beta.sh to package-zgx-macos.sh): resolved as stable-zgx's
text with the fix applied to it, the same 28 lines.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Co-authored-by: zeronsh[bot] <346184242+zeronsh[bot]@users.noreply.github.com>
2026-11-11 10:57:18 -07:00
Wing
96a5e4b728 The Linux and Windows zgx builds take Luau's NDEBUG, and each package checks it
Cargo reads .cargo/config.toml by where it runs, not by --manifest-path.
LUAU_CXXFLAGS=-DNDEBUG is in apps/zgx/.cargo/config.toml (the root has
none), and package-linux.sh and package-windows.ps1 built apps/zgx from
the root: the Linux and Windows betas ran Luau with its asserts, about a
fifth of script time, and since zgx 06c6d56ac warned of it on every
script load. package-zgx-beta.sh builds from apps/zgx, so macOS's was
right.

Both now build from apps/zgx, as macOS does. Their target is the one
they used (apps/zgx/target: Linux's paths absolute as before, Windows'
`target` from apps/zgx); the binary each reads afterwards, and the
package, its checks and uploads under target/package, are where they
were. The engine's builds, steps of their own, are untouched.

Each of the three packages refuses an app built with the asserts: zgx-
script compiles its warning about them ("Luau was built with its
asserts", crates/zgx-script/src/lib.rs) into the binary only under
cfg(all(luau_asserts, not(debug_assertions))), the cfg its build script
sets from the same LUAU_CXXFLAGS that Luau's C++ is built with.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Co-authored-by: zeronsh[bot] <346184242+zeronsh[bot]@users.noreply.github.com>
2026-11-11 10:56:26 -07:00
Wing
6bf634308b Stable releases ship the zgx app, installable by every shipped Zeron
release.yml builds the zgx app through zgx-build.yml, the build zgx-beta.yml
now shares, and keeps the old app behind `app: gpui` / STABLE_APP for a way
back. Its manifest says minimumMacOS 13.0, which shipped updaters honour.

Windows: the old app's updater installs only zeron-<v>-windows-<arch>.exe.
That zeron.exe now completes its own install on first start: it fetches the
release's zip from its feed (checksum from the feed's manifest), unpacks its
version's folder (app\<v>\, a beta's beta\<v>\), and offers Retry on failure.
Its later updates come as the zip on every channel.

Linux: zgx's libdbus is linked in (libdbus-sys vendored), so `zeron
headless` on servers and Cloud machines needs no library the old app didn't;
the build checks that.

zgx-beta.yml's manifest gave stable's engine version; it's the beta's own.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Co-authored-by: zeronsh[bot] <346184242+zeronsh[bot]@users.noreply.github.com>
2026-11-11 10:47:23 -07:00
Wing
51b0e1dc43 Merge zeron/zgx into the Cloud, relay and GitHub work
Conflicts resolved:
- Engine checkpoints: zgx's upload in parts now carries the relay layer's
  atFloor/heal flags and hands the edge's refusal back to the relay state.
  The engine's own size cap follows the room's (256 MB in parts), so a long
  chat's checkpoint isn't held back before it's sent.
- Attachments: zgx's local copies of another device's uploads, rewritten with
  the app-capture attribute escaping.
- zgx app: zgx's composer, mention sections, link chips and remote harness
  retries, with the Cloud machine notices, held messages and turn states on
  top; v2 template base re-recorded.
- Linux packaging: zgx's beta packaging, keeping the fat-LTO engine build.
- apps/zgx Cargo pins: zgx's.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-09 23:21:27 -07:00
Wing
e0365a26ea Plugins launch: one SDK everywhere, zgx tests in CI, install.sh guards ~/.zeron
- A4: re-copy apps/zgx/plugins-sdk/zeron.luau into all 14 copies (git,
  github, parallax-scenes, 11 plugins-dev examples); 12 lacked the agents
  block, all lacked the "project" context fix. examples_tests
  `sdk_copies_match_canonical` checks them byte for byte. The beta packaging
  (macOS, Linux, Windows) stamps the canonical SDK into each shipped builtin,
  so builtins can't ship a stale one. Builtins aren't signed (the engine scans
  them as Zeron's own), so nothing to re-sign.
- A6: a `zgx` CI suite (zgx-tests.yml, planned by scripts/ci/plan.py): apps/zgx
  unit tests and the Luau UI tests (`zgx test ui`, CLI at the pinned rev) on
  macOS and Linux, plus the engine's plugin tests on macOS. Known failures
  (10 Rust, 2 Luau About tests) live in scripts/ci/zgx-known-failures.txt;
  anything else fails. core-tests also runs engine tests/plugin_services.rs.
  No Windows job yet.
- B13: plugins-dev/install.sh refuses ~/.zeron as well as ~/.comet-native
  (and anything under them, symlinks resolved); its default is every example.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-09 16:26:20 -07:00
Wing
582367628b Build the Linux release with fat LTO in one codegen unit
zeron goes from 205 to 172 MB (16% less; the tarball 103 to 90 MB), with the
same start-up: a median engine boot of 387 ms both ways (n=20 each), --version
5.3 vs 5.7 ms. A Cloud machine copies the binary back in on every wake, so its
size is wake time. The release was already stripped, with no debug info to
split; opt-level stays 3. It costs about 60% more build time, so only the Linux
package does it: macOS and Windows keep theirs.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-07 01:55:54 -07:00
Wing
dd55507797 zgx beta: the engine comes from the same commit
A beta tests what's next, the engine too. It compiles the engine from its own
commit on every platform, rather than downloading the latest stable release's.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Co-authored-by: zeronsh[bot] <346184242+zeronsh[bot]@users.noreply.github.com>
2026-11-05 19:02:52 -07:00
Wing
edcb78ebf1 zgx beta: Linux and Windows
Linux (x86_64, aarch64) and Windows (x86_64) beside macOS: the zgx interface and
the latest stable's own engine, by checksum, with stable's artifact names but
the beta's version. Windows has no standalone .exe, which can't run alone.
Every key stays under beta/, the manifest last, listing every platform's files.
A run by hand can pick platforms.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Co-authored-by: zeronsh[bot] <346184242+zeronsh[bot]@users.noreply.github.com>
2026-11-03 22:32:26 -07:00
Wing
cc7da5c2aa
Zeron Cloud, provider switching, and the phone model picker (#966)
Cloud chats on machines of their own (delegation, sleep/wake, durable delete), a credential vault, Stripe billing with Cloud's own portal, per-account Cloud availability, the edge's Cloud model list, provider switching between turns, the phone's tabbed model picker, and desktop/phone/engine polish.
2026-10-22 03:18:13 -07:00
José Gurruchaga
4a5fb8b443
Internal session plumbing and packaging cleanup (#819)
* test(codex): document and probe native voice capabilities

* feat(proto): define local voice session contracts

* fix(harness): bound realtime media and prioritize control messages

* feat(codex): attach realtime voice to an idle thread runtime

* feat(engine): own voice leases and enforce subscription eligibility

* feat(mcp): create standalone sessions on selected hosts

Add chat/side kinds with compatible defaults, resolve projects within the selected device, and validate that host's harness and model catalogs before writing. Route transcript reads to the chat host and preserve send baselines across waits so missing session rows and delayed replies cannot return an old response.

Cover invalid requests, remote catalogs, mixed batches, wait races, two-engine execution and interrupt delivery. Add an isolated MCP stdio smoke fixture.

* feat(doc): persist canonical voice transcripts once

* docs(mcp): document standalone and remote session workflows

* feat(audio): add native capture and streaming playback

* feat(audio): handle echo cancellation and voice interruptions

* feat(ui): coordinate voice ownership over local engine RPC

* feat(ui): extract the Bezel orb into a native Zeron component

* feat(ui): replace the composer with a central orb during voice sessions

* feat(mcp): constrain voice orchestration to subscription policy

* build(voice): add microphone permissions and offline audio CI

* test(voice): verify lifecycle, billing boundaries and rollout gates

* fix(voice): preserve text transport and idle billing boundaries

* feat(codex): connect subscription voice through native WebRTC

* feat(engine): activate native voice ownership and preserve delegated work

* feat(ui): enable native voice with central orb and retained drafts

* fix(mcp): keep voice delegation on subscription-backed Codex

* test(voice): document native transport and add opt-in connectivity smoke

* fix(voice): close audit races and validate project subscription context

* Fix Codex voice initialization and macOS microphone permissions

* Allow Codex voice agents to delegate through upstream MCP

* Make voice a persistent orchestrator with a dedicated stage

* Add call controls and elapsed time to the voice stage

* Remove decorative rings around the voice orb

* Add voice selection menu and simplify stage artwork

* Remove voice status labels beneath the orb

* Fix dictation and realtime voice integration after rebase

* Move Codex voice style selection into Voice settings

* Restore window dragging from the voice stage titlebar

* Open the voice stage immediately when starting a call

* Smooth voice orb motion and speaking transitions

* Remove the green audio pulse from the voice microphone control

* Show the live voice orb above the orchestrator chat composer

* Use full chat IDs in MCP reply instructions

* Correlate MCP replies by message IDs instead of remote timestamps

* Keep the voice stage open when launched from Settings

* test(voice): add a split-host Codex voice compatibility probe

* feat(voice): package a standalone desktop media runtime

* feat(proto): define client-media voice control contracts

* refactor(codex): separate voice signaling from local audio

* feat(engine): own remote voice sessions with ephemeral leases

* feat(rpc): route versioned voice controls to execution hosts

* feat(voice): coordinate local media with remote Codex control

* feat(ui): start voice on a selected remote Codex host

* test(voice): cover cancelled preparations and stale session controls

* test(voice): prepare desktop rollout validation and offline CI

* feat(ios): add a pinned native WebRTC compatibility endpoint

* feat(mobile): expose remote voice sessions through UniFFI

* feat(ios): bridge native audio lifecycle to remote voice calls

* feat(ios): add remote voice controls and registered host selection

* test(voice): cover relay and iOS lifecycle and prepare live acceptance

Add half-open and native callback regressions, stage-only diagnostics, complete runtime notices, and development test instructions. Keep real Mac/Fedora/iPhone acceptance opt-in for user validation.

* refactor(orb): share the thinking-orb engine through zeron-orb

Move the renderer-agnostic engine, presets, motion and a new OrbAnimator
(clock, audio response, state crossfades) into crates/orb. The GPUI widget
now delegates to the animator, so desktop and mobile paint identical frames.

* feat(voice): rebuild iOS remote voice around the desktop orb and phone-call audio

- Share the call view (phase, caption, levels, speaking, orb state) in
  voice-session; the client derives speaking because client media has no
  host meter. Keep owner-event headroom so level meters never overflow it.
- Title remote orchestrator chats "Voice session" like local ones.
- UniFFI: typed call state and end reasons instead of JSON, a distinct
  denied-microphone failure, and OrbRenderer frames from zeron-orb.
- iOS: OrbView paints the desktop orb; start voice from the New session bar
  (live strip while a call runs), the session nav bar and the iPad sidebar;
  full-screen call stage with caption, transcript (flagged when Codex waits
  for an answer), mute, route picker and hang-up.
- Phone-call audio: proximity sensor moves output to the earpiece, headsets
  win, calls survive screen lock, headset loss re-routes instead of ending.
  Install the WebRTC audio configuration globally so it is not reverted when
  the audio unit starts.

* fix(voice): install the macOS voice runtime under codex-resources/voice

Codex's helper only initializes from a codex-resources/voice directory and
exits with code 23 on initializeRuntime anywhere else, which the desktop
reported as "Voice could not connect". Bundle the runtime at
Contents/Resources/codex-resources/voice, reject other locations up front,
and report a helper that cannot start as an unavailable runtime.

Ship the runtime byte-for-byte with OpenAI's Developer ID signatures instead
of re-signing it ad hoc.

* fix(ios): reopen the call stage from the live strip and redo voice settings

The live strip in the bottom bar is a plain UIControl, which never sends
.primaryActionTriggered, so tapping it did nothing; listen for touchUpInside.
UI tests cover reopening the stage after the transcript and after minimizing.

Voice settings now follow the Settings list style: the resting orb, the
devices Codex can run on with their status, the voice as a pop-up menu, and
what to expect during a call.

* fix(ios): resume the orb animation when the app becomes active again

At willEnterForeground the app still reports .background, so the display
link never restarted and the orb stayed frozen after returning from Home.

* fix(ios): guard voice preview state in Release builds

* feat(voice): veil streamed caption words in on desktop and iPhone

Move the transcript's renderer-agnostic streaming veil into zeron-veil so
the voice call caption can use the same chunk fades on both platforms. A
new CaptionVeil keeps the veil aligned with the ellipsized tail and fades
the previous utterance out when the speaker turn changes; reduced motion
shows text directly. Desktop recolors GPUI runs; iOS gets UTF-16 spans
through CaptionFader and paints an attributed caption on a display link.
The desktop transcript keeps its behavior; the iOS transcript is untouched.

* fix(ui): step the voice stage aside when opening any session

Opening a session only hid the stage indirectly, when the selection changed,
so clicking the thread already under the stage (or the one you came from
Settings) did nothing. open_chat now hides the stage explicitly; the call
keeps running in the background.

* feat(voice): reuse host orchestrator chats across calls

* fix(voice): reserve orchestrator atomically and preserve rotation retries

* feat(voice): rotate the orchestrator transcript after 1000 entries

* feat(voice): package remote media runtime for Linux and Windows

* feat(voice): use the installed Codex helper everywhere and stop bundling it

Remote voice now plays audio through the client's own standalone Codex
installation, like local voice, instead of a runtime packaged inside
Zeron. The resolver moves to zeron-voice-media and is shared by the
harness and the desktop media endpoint; ZERON_VOICE_MEDIA_DIR remains a
development override. macOS, Linux and Windows packages no longer
contain Codex binaries, GStreamer/GLib or the Visual C++ runtime, so
Zeron takes on none of their redistribution or update obligations.
package-voice-runtime.py stays as a development projection tool.

Missing-runtime messages point to Codex's official installer, since npm
installs lack the voice runtime.

Notices and disclosures:
- THIRD_PARTY_NOTICES: full MIT chain for the orb (Bezel,
  gpui-thinking-orbs, thinking-orbs), Codex NOTICE, OpenAI trademark and
  non-affiliation statement, and WebRTC for iOS.
- The iOS app carries the orb's MIT notice; the Linux tarball now ships
  LICENSE and THIRD_PARTY_NOTICES.md.
- Microphone purpose strings on macOS and iOS state that voice sessions
  stream audio to OpenAI; dictation stays on device.
- Docs describe the voice data flow, and the acceptance checklist lists
  the legal and privacy decisions that block a public release.

* feat(ios): show the voice call in the Dynamic Island and on the Lock Screen

* fix(voice): hide the voice trigger when this device has no Codex

The microphone in the sidebar footer only shows when Codex is installed and
enabled on this device, following the same catalog the composer offers. It
re-reads after Settings → Agents changes and when returning to a window that
hides it. A start without Codex now asks for an install instead of a retry.

* test(voice): seed the real rotation threshold in the remote rotation test

* feat(voice): sound the start and end of a call on desktop and iPhone

A call sounds as it is placed, before the microphone opens, and again when
the user hangs up or a connected call ends. A failure to connect stays quiet
and explains itself. Nothing sounds in between. The iPhone plays them as
system sounds, so they follow the ringer switch.

* perf(voice): skip the rate limits round trip before each call

The pre-call probe read account/rateLimits/read, a ~1 s backend round
trip, and ran twice per call (prepare and negotiate). Its result was never
shown: the native backend makes the final usage decision. Dropping it
saves about 1.7 s per call on desktop and iPhone.

* perf(voice): release the orchestrator runtime 5 minutes after hang-up

The voice orchestrator's Codex runtime and MCP servers hold ~200 MB. Its
idle window was the generic 30 minutes, counted from the runtime's start,
so a call ending late in the window left a runtime reaped right after the
hang-up. It now idles 5 minutes, restarted at each hang-up.

Hang-ups wake the reaper directly, so even a short call restarts the
window, and a reap armed before a call began rechecks for it instead of
cutting the call.

* fix(voice): enable client-owned remote voice by default

* fix(harness): read whole resumed histories and report why stdout failed

509818ed capped every JSON-RPC line at 8 MiB on the transport shared by
text chats. A resumed long chat returns its history in one response
(54-71 MiB measured), so resume failed and was reported as an exit even
though Codex was alive. Lift the cap (voice bounds its own messages) and
keep the read error's cause for every waiting and later request.

* fix(harness): name the rejected request in JSON-RPC errors again

dca9a05f made peer rejections structured but dropped the method from
their message, so chats showed 'JSON-RPC rejection -32600: …' without
saying which request failed. Prefix the method again and render it as
upstream did, keeping the code available for auth detection.

* test: skip POSIX mode check on Windows hosts

* fix: launch Codex batch shims from plain paths and answer account/read in fake

* refactor(engine): remove the superseded local session RPC surface

The client-media protocol replaced these methods; nothing calls them anymore.

* refactor(harness): restore the shared JSON-RPC transport

Return the stdio transport every agent uses to its upstream behavior
(unbounded writes, no timeouts or polling timers) and keep only an
additive notification route that is registered while a subscriber
exists.

* fix(ui): let the full-window stage show the window glass

On translucent appearances the stage painted an opaque fill unlike the
new-thread page. Drop the fill there and fade out the page it covers.

* fix(ui): show the full-window stage over Settings

Settings replaces the workspace layout and never mounted the stage, so
opening it from there did nothing. Mount it beside the settings sidebar
and fade the page it covers.

* fix(voice-session): keep the live caption on the newest turn

Turns arrive interleaved: a user final often lands after the answer has
started streaming. Keep each turn's text separately and caption the
newest one, so a late final never takes the caption back and deltas
never restart it. Desktop and mobile now share this state.

* ci: build the desktop UI only in the UI workflow

The offline-linux job compiled zeron-ui without the WebKitGTK and
JSON-GLib packages its build script requires, so it failed every run.
Drop its UI step; the UI workflow already runs those lib tests and now
also runs the orb geometry test.
2026-10-06 23:47:32 -07:00
Gaël Cado
80b946b153
Add opt-in on-device dictation to the desktop composer (#591)
* feat(voice): add local Parakeet v3 capture and transcription backend

* feat(ui): add opt-in dictation settings and composer controls

* build(macos): package microphone permissions and voice attribution

* docs: describe desktop dictation behavior and runtime limits

* fix(ui): clarify dictation states and cancellation controls

* fix(ui): keep composer model controls right aligned

* feat(ui): give Voice a dedicated settings page

* fix(voice): support all native microphone sample formats

* fix(voice): retain model cleanup after interrupted downloads

* fix(ui): preserve dictation while pasted references resolve

* fix(ui): cancel dictation with Escape across composer controls

* fix(ui): refresh dictation state after empty undo and redo

* fix(ui): preserve dictated words on blank recognition results

* fix(voice): clarify retries while native inference finishes

* test(ui): verify repeated Send preserves unfinished dictation

* style(ui): format settings modules

* feat(voice): add microphone selection and streamline Voice settings

* feat(ui): visualize live dictation with a waveform and recording clock

* fix(ui): preserve waveform paint opacity

* feat(ui): morph composer controls into dictation track

* test(voice): exercise real inference on every desktop release target

* fix(voice): keep device choices fresh and cancellation accessible

* ci(voice): verify Linux release packages on x86 and ARM

* ci(voice): keep model and package probes out of permanent CI

* fix(voice): detect missing ALSA before activating Linux installs

* fix(voice): capture audio while Parakeet loads

Run capture independently of serialized model loading and inference. Retain stopped audio until the model is ready, close capture before reporting load failure, and hold admission through native work and stream teardown.

Cover loading, cancellation, device startup, rapid Stop, admission, and recording limits with deterministic coordinator tests.

* test(ui): verify and measure nonblocking dictation startup

Cover selected-draft preservation, delayed final results, single Send delivery, and late results after loading failures or finalization timeouts.

Add transcript-free debug timing from dictation activation to the Listening state and clarify asynchronous capture cancellation.

* docs(voice): explain concurrent capture and startup timing

Document audio retention during loading, cancellation and model-removal limits, race coverage, and the native startup timing procedure.

* fix(ui): stop Shell saves from reverting settings chosen elsewhere

The Shell republished its whole cached UiSettings on every save
(navigation, pane resize) and only refreshed a hand-kept list of fields
first. Anything missing from that list was silently reverted: leaving
Settings → Voice turned dictation off, and the microphone choice,
compact transcript, fit-content code fences, and diff split/wrap toggles
had the same bug.

Replace the list with a three-way merge against the store snapshot the
Shell last synced: fields the Shell changed win, every other field keeps
the store's value. The merge destructures UiSettings exhaustively, so a
new field fails to compile until it is merged too.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* feat(voice): hold to talk, default Cmd+D, shortcut on the Voice page

Dictation is now hold to talk. Holding the microphone (pointer, or
Enter/Space while it is focused) or the shortcut records; releasing
transcribes. A pointer release outside the button still counts. For the
shortcut, letting go of its key or any of its modifiers ends the hold,
because macOS does not deliver key-up for Command chords. A release
within 300 ms explains hold to talk instead of transcribing a blip, and a
release that only answered the permission prompt records nothing.
Assistive-technology Click still starts and then finishes, since it
cannot hold.

The default shortcut is Cmd/Ctrl+D (unbound elsewhere). Its rebinding row
moves from Settings → Shortcuts to Settings → Voice through a reusable
ShortcutField that shares the Shortcuts page's chip and conflict rules.
Settings → Shortcuts re-reads the stored keymap while not recording, so
its own commits cannot revert a binding changed on the Voice page.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(voice): harden capture, worker and download against edge cases

- Keep the capture flags outside the sample lock. The capture loop polled
  them under the mutex every 10 ms, so the real-time callback's try_lock
  could fail and drop a buffer of speech.
- Catch a native panic on the worker. A panicking job killed the only
  worker thread, leaving every later session "unavailable" until restart.
- Keep loaded weights when a session fails for a microphone or recording
  reason; dropping them made the next attempt reload 670 MB.
- Time out a download request whose response headers never arrive.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(ui): dictation review fixes for focus, shortcuts and Windows

- Enter/Space hold on the focused microphone no longer moves focus to the
  editor, which sent its key-up (and auto-repeat spaces, or Enter-to-send)
  to the draft and left the microphone live.
- A key release caused by focus leaving no longer pulls focus back, and an
  unparseable stored shortcut falls back to the default when matching its
  release, as apply_keymap already does.
- Another source can take over a hold whose release went missing, so the
  microphone or shortcut can always end it.
- Dictation cannot start while a queued row is acquiring its edit lease,
  which would replace the draft and silently drop the transcript.
- With dictation off (the default) ⌘D propagates to any other binding of
  the chord instead of being swallowed in the composer.
- The Voice page's shortcut row is always shown, conflicts with a feature
  page's shortcut name that page, and recording stops if the window closes
  so Appshots' capture shortcut is never left suspended.
- Show Settings → Voice on Windows; the PR ships the Windows backend and
  only Appshots is macOS/Linux-only.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(ui): give the composer microphone its siblings' hover

At rest the microphone snapped to a different surface colour on hover;
it now uses the paperclip's eased ink wash. While live it dims like Send,
and its focus ring and tooltip match the neighbouring composer buttons.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

---------

Co-authored-by: Wing <contact@winglee.io>
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-01 15:16:51 -07:00
Daniel Katulevskiy
11c9108940
Linux: install a launcher entry and icon with both installers (#627)
* Linux installers: add a launcher entry and icon

The curl installer extracted the release tarball but never ran the
tarball's install.sh, so no .desktop entry or icon was ever written and
Zeron did not show up in application launchers.

The tarball's own install.sh did write an entry, but copied the shipped
one verbatim: `Exec=zeron` and `TryExec=zeron` need ~/.local/bin on the
desktop session's PATH, which is often missing (bare Wayland/fuzzel/rofi
setups), and TryExec then hides the entry entirely. Both installers now
render the entry with absolute paths through ~/.zeron/app/current (stable
across in-app updates), reference the icon by path because the only
artwork is 1024x1024 (not a size the hicolor theme indexes), honor
XDG_DATA_HOME, quote Exec per the Desktop Entry spec, write atomically,
and refresh the desktop/icon caches only when those tools exist.
StartupNotify is added to the template; StartupWMClass=zeron already
matches the app_id the UI sets.

scripts/test-linux-desktop-entry.sh runs both installers offline against
a fake release under a throwaway HOME.

* Linux installers: keep the download cleanup, don't create an icon cache

install_desktop_entry reused `tmp` for its staging file. The curl
installer runs under sh, which has no `local`, so this overwrote the
download dir its EXIT trap removes and left every downloaded tarball
behind in $TMPDIR. Use `entry_tmp` in both copies.

gtk-update-icon-cache -f created ~/.local/share/icons/hicolor/
icon-theme.cache when none existed. Nothing else maintains a user-level
cache, and a stale one hides icons other apps later install there; the
entry references the icon by path anyway. Only refresh an existing one.

The test now gives each run its own TMPDIR and requires it empty, fails
if an icon cache appears, and checks the two copies of the function are
identical. A small workflow runs it on changes to the installers.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

---------

Co-authored-by: Wing <contact@winglee.io>
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
2026-09-29 11:12:04 -07:00
Wing
109b39f301
Durable desktop updates: Check for Updates, background download, install on quit, Windows installer (#595)
Update detection was late and fragile: the only checker lived in the engine
on a 6h monotonic timer (a laptop's sleep stretched it by the whole night),
the sidebar compared the release against whichever engine the UI attached to
(a daemon of another version hid or faked updates), nothing downloaded until
clicked, and several install paths could not update at all.

- zeron-update: hourly wall-clock schedule with failure backoff (1m→30m),
  re-read on window activation; desktop (report-only) checker role; staged
  payloads are unpacked beside their final name and must answer
  `--version` with the promised release before they can replace anything;
  up-front blockers (App Translocation, disk image, unwritable install dir)
  instead of a failed download; Linux managed installs update from the app;
  a service daemon restarts into a newer installed binary once idle.
- UI: app-level controller with its own checker against this binary; a found
  release downloads in the background, the strip offers restart, and a
  staged update installs on quit. "Check for Updates…" under About in the
  macOS app menu, "Check for updates" in the account menu elsewhere, with a
  live result dialog.
- Linux: the tarball's install.sh uses the self-updating ~/.zeron/app layout.
- Windows: per-user Inno Setup installer (LocalAppData, Start menu, zeron://,
  uninstall entry kept current after in-app updates), built in release and
  CI, with a silent install/uninstall smoke test.
- Fix: closing the window on X11 panicked in the geometry save, skipping the
  engine drain and any quit hooks.

Co-authored-by: wing-anara <wing@anara.com>
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
2026-09-27 17:46:55 -07:00
José Gurruchaga
fbcd9819b9 Merge upstream/main into typography PR 2026-08-14 08:29:39 -04:00
wing-anara
b0be3dea2f rename: comet -> zeron everywhere (binary, crates, env, data dir, iOS)
- binary/CLI `comet` -> `zeron`; crates comet-* -> zeron-*; COMET_* -> ZERON_*
- data dir ~/.comet-native -> ~/.zeron, with a one-shot rename migration
- services: comet-native.service -> zeron.service; launchd sh.zeron.comet ->
  sh.zeron.app; macOS bundle id dev.comet.native -> sh.zeron.app
- release artifacts comet-<ver>-* -> zeron-<ver>-*; drop the Comet.app
  tarball-path compat hack in package-macos.sh
- iOS: Comet -> Zeron targets/dirs, bundle id sh.zeron.Zeron, zeron:// scheme
- clients default to https://edge.zeron.sh; installer + landing on zeron.sh
- kept on purpose: repo name, worker names (comet-native-edge/comet-landing;
  DO storage is bound to the script name), R2 bucket names, and legacy
  comet.zeron.sh routes so 0.1.x clients keep working

zeron-<ver>-* artifacts don't exist until the next release, so curl-install
and landing downloads 404 between this deploy and the 0.2.0 tag.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2026-08-14 10:49:19 +00:00
José Gurruchaga
34c2d9ed4d Merge remote-tracking branch 'upstream/main' into t3code/implementar-tipografia-ui-configurable 2026-08-13 08:04:47 -04:00
Wing
0415c39817 Brand desktop app as Zeron 2026-08-12 15:39:53 -07:00
José Gurruchaga
befd129a5c feat(ui): add bundled interface font catalog 2026-08-11 19:02:44 -04:00
Wing
ff5e3dc508 Ship the real comet icon, not the placeholder
dist/comet.png is now the original app's 1024×1024 mark (comet repo
apps/desktop/resources/icon.png — the pixel-comet on the black rounded
square), with icon.svg alongside as the vector source. The macOS
iconset gains @2x retina variants now that the source is big enough;
the Linux hicolor install path moves to 1024x1024 to match.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2026-07-23 18:40:26 +00:00
Wing
e8c59b8278 M6: wire reconciliation, live two-device e2e, packaging, polish
Engine emits proto AuthState shape; LocalDevice RPC served; accounts param
aliases. scripts/e2e-smoke.sh + rpc examples (e2e_driver, rpc_probe): edge
under wrangler dev, two headless engines, chat created on A, run queued from
B through the doc command queue, host-executed on A, transcript + status
synced back to B — ALL STEPS PASS LIVE. dist/ packaging (Linux .desktop +
icon + package-linux.sh, macOS Info.plist template + docs), release profile
(thin LTO, strip). Clippy/fmt clean; docs/PARITY.md honest feature ledger;
README + ARCHITECTURE status refresh. Workspace: 311 tests green.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2026-07-20 04:03:21 +00:00