Skip to content

Doubao-powered voice input for Linux, Wayland and Omarchy

8.6 KB
Raw Blame

In-app updates

The client checks the latest public stable release every 24 hours. Version 1.5.2 and later read the public releases/latest/download/update.json asset first and fall back to the GitHub Releases API if it is unavailable or invalid. Neither source needs application credentials. Manual checks bypass that interval. Updates are downloaded and installed only after the user chooses the update action and dictation, polishing and text delivery are idle. The installer runs after the old process exits, then restarts the application. This is an application update; it requires a restart.

Linux

Official clean Git installations fetch the explicit stable release tag into a separate staging repository, then switch the installed checkout after exit. Local edits and a changed HEAD block replacement. Existing runtime dependencies must pass the new version's installation and launcher checks; a failed check restores the old revision and branch. If new dependencies are needed, use the normal installer before retrying.

Managed archive installations download the app or plugin archive matching the installed CPU and Python ABI. The archive and bundle file hashes are verified before the bundled installer runs. App and shared runtime backups are retained under the user's configuration directory in doubao-say/updates/pending-*. Installation-check failures restore those backups. Omarchy plugins are disabled before replacement and rediscovered and enabled afterwards. Runtime failure receipts are shown when the application opens again.

System packages and relocated archive installations must use their original installation method. A Linux desktop is still required to verify real Omarchy restart, microphone and physical hotkeys; portable unit tests do not prove these.

macOS

Settings → Updates and the menu show update availability. Downloads display progress and can be cancelled before application replacement. The running app must be installed in a writable location outside the mounted installer image. Move it into Applications first. Developer ID, bundle ID, release version, SHA-256 and Gatekeeper notarization are checked before staging. Installation retains the previous application as .DoubaoPrevious-<UUID>.app beside the app; failures to move or launch restore it. Credentials remain in Keychain and preferences remain in UserDefaults. Application crashes after successful launch are not detected as installation failures.

Build both CPU variants separately when distributing both:

DOUBAO_MAC_ARCH=arm64 DOUBAO_CODESIGN_IDENTITY='<Developer ID Application identity>' \
  ~/.local/bin/dev-gate run -- bash macos/build.sh
python3 macos/package-dmg.py --arch arm64 --identity '<Developer ID Application identity>' \
  --key '<App Store Connect private key path>' --key-id '<key ID>' --issuer '<issuer UUID>'

Repeat for x86_64. The package script produces a signed, notarized and stapled Doubao-Say-<version>-macos-<arch>-<commit>.dmg and its .dmg.sha256 file.

For each authorized stable release, include exactly one matching DMG for each supported Mac CPU. Append its checksum line to the release's Linux SHA256SUMS, keeping every Linux archive entry. Publish the combined SHA256SUMS alongside the Linux archives and Mac DMGs under the same newer tag. A DMG shared through Feishu does not populate this feed. Never overwrite a tag or remove Linux hashes when adding Mac assets. Missing compatible assets are reported in the client.

Version 1.5.0 is the first release with both Mac DMGs and Linux archives in this feed. Older 1.4.0 Mac previews can upgrade to it through a manual update check; subsequent releases must increment the version in every product version source. Release tags must point to the protected-main merge, and each DMG must be built from that same commit. Build and notarize the Mac artifacts before pushing the tag. After the Linux release workflow succeeds, upload both DMGs, merge their .dmg.sha256 lines into the published SHA256SUMS without removing Linux hashes, and verify the public latest-release endpoint and every download. This local signing/upload step uses publisher tools only; no signing key, Feishu credential or GitHub token belongs in application source or release artifacts.

After uploading both Mac DMGs and the combined SHA256SUMS, publish the minimal metadata using python3 packaging/publish-update-feed.py --tag v<version>. The command requires a public stable release, exactly one Mac DMG per architecture, all eight Linux archives, official asset URLs and matching checksum entries. It omits release body, uploader/account fields and credentials. Verify the public releases/latest/download/update.json URL and both update-source paths. Older clients that cannot reach the API need one manual DMG upgrade to get this fallback.

Local Mac development signing

Pin a certificate for local builds so successive app replacements keep a stable code-signing identity for macOS permission checks:

security find-identity -v -p codesigning
git config --local doubao.codesignIdentity '<certificate SHA-1>'
bash macos/build.sh

The setting stays in this checkout's local Git configuration. An explicit DOUBAO_CODESIGN_IDENTITY overrides it. Local builds fail without a configured identity instead of silently falling back to ad-hoc signing. PR CI builds still use ad-hoc signing for tests and do not distribute an installable app; DOUBAO_CODESIGN_IDENTITY=- explicitly requests a disposable local preview. Changing from ad-hoc to certificate signing may require one more permission grant. Release DMGs still require Developer ID signing and notarization.

Signed Mac previews

Installable previews use the same Developer ID signing team and bundle ID as the release DMGs. They are notarized and stapled before upload. The protected-main preview job in .github/workflows/macos.yml runs after the Mac checks on a main push or a manual run on main. Pull-request builds publish only opt-in test probes; they cannot access signing credentials or distribute an ad-hoc application ZIP. Dispatching the workflow on another branch does not start the signing job.

Configure the macos-preview GitHub environment before merging this workflow. Restrict its deployment branches to protected branches and keep main protected. Set the environment variable MACOS_SIGNING_TEAM_ID to the existing release team. Add these environment secrets through GitHub Settings → Environments → macos-preview (never through source files, issue comments or chat):

Secret Value
MACOS_CERTIFICATE_P12_BASE64 Single-line base64 of the release Developer ID Application certificate and private key, exported as PKCS#12
MACOS_CERTIFICATE_PASSWORD Nonempty password protecting that PKCS#12 export
MACOS_NOTARY_KEY_P8_BASE64 Single-line base64 of the App Store Connect API private key used for notarization
MACOS_NOTARY_KEY_ID That API key's key ID
MACOS_NOTARY_ISSUER_ID That API key's issuer ID

The job imports the certificate into a temporary keychain, permits codesign access, requires exactly one valid Developer ID Application identity and verifies that the app's team matches the configured release team. Missing credentials, a team mismatch or failed notarization fail the job; no unsigned fallback app is uploaded. An always-run cleanup step removes the temporary keychain and credential files. Only the DMG, checksum and public provenance manifest are uploaded.

The preview job builds both CPU variants. Download Doubao-Say-macos-signed-preview-arm64 or Doubao-Say-macos-signed-preview-x86_64 from the successful workflow run. The manifest records the exact source commit, architecture, bundle ID, signing requirement and artifact hash. Replacing an older ad-hoc or Apple Development build may require one final permission grant. Successive Developer ID previews and releases with compatible signing requirements should retain existing grants. Real permission retention across two distributed previews still needs acceptance on a Mac; synthetic signing tests do not establish that result.

Recover a release workflow after a runner change

The Linux Python 3.12 installation smoke test runs on Ubuntu 24.04 so its system Python and GTK bindings match the downloaded archive. If a workflow fix is needed after tagging, merge the fix and dispatch release.yml on main with source_tag=v<version>. All jobs use the existing tag's resolved commit; the manual run verifies and builds artifacts but never publishes automatically. After its gates pass, publish those artifacts under the unchanged tag and retain the Mac DMGs built from that same source commit. Never move the tag.