Skip to content

chore: release 1.0.3b5 - #2941

Merged
jubaoliang merged 25 commits into
mainfrom
release/1.0.3b5
Nov 11, 2026
Merged

jubaoliang merged 25 commits into
mainfrom
release/1.0.3b5

Conversation

@jubaoliang

Copy link
Copy Markdown
Collaborator

[1.0.3b5] - 2026-11-11

新增

  • 桌面客户端改为 Electron 壳,登录过期后自动续上
  • 自定义 MCP 可填写 OAuth 应用凭证并完成授权
  • 新增 octop migrate openclaw / octop migrate hermes,把原有助手迁到一个专家
  • 知识库内的文档和文件夹可以移动。共享专家上可以分享对话
  • 专家市场默认打开「精选」。管理员可按用户查看用量

变更

  • 桌面端不再使用 Wails
  • 升级 octop-harness 至 1.0.9、octop-memory 至 1.0.4

修复

  • 下线 history v2,启动时把已有归档迁回原有历史表
  • 云端协同不再因心跳超时反复断开
  • 共享会话的回复不再重叠。聊天里的模型和提问顺序保持正确

Release checklist

  • CI green
  • Merge this PR into main
  • After merge, GitHub Action auto-pushes v1.0.3b5 tag on main tip

Made with Cursor

wxhking and others added 25 commits November 5, 2026 17:17
…ard path

_build_dashboard_request resolves the turn's reasoning overrides and hands
them to build_harness_request, so Dashboard turns send the configured
reasoning_effort through the harness's reasoning middleware. The IM path
inside __call__ skipped both steps: the request was built without
reasoning_overrides, so a model whose reasoning_config.default_effort
(e.g. high) was set sent no reasoning_effort at all on WeChat/QQ/Feishu
turns — the same conversation proved it from the same provider when asked
from the Dashboard.

Resolve the overrides for IM turns with the same call (meta=None: IM
metadata carries no per-turn reasoning overrides) and pass the result
into build_harness_request.

Fixes #2785
….0.3b4

chore: sync main into develop after 1.0.3b4
GitHub retired the macos-14 runner on 2026-11-02, so the v1.0.3b4 desktop job was cancelled before a runner was assigned.
…ab failures (#2874)

* fix(models,bridge): keep pool preference out of chat and explain collab failures

The starred model is only a harness auto-route preference, so the chat picker shows an expert default or an explicit choice. Permanent cloud-collab rejections now fail immediately with a readable error instead of a raw close frame.

* docs: record preferred-model and bridge error fixes

* fix(db): close SQLite only after in-flight queries finish

Windows aborted the process when server shutdown closed the shared connection while the idle reclaim sweep was still reading agents.

* test(agents): initialize the reclaim sweep handle on stub managers

* test(bridge): wait for both listen frames before cancelling
…#2878)

Keep pauses, themes, citations, backups, and chat chrome from colliding, and show the templates that shipped before the expert market as the default featured set.
* feat(chat): share conversations on a shared expert

Owners can mark a thread as shared so anyone who can open that expert can read it, follow up, and handle pending approvals. Composer settings stay with the owner, and the chat expert menu can open the existing edit drawer.

Co-authored-by: Cursor <cursoragent@cursor.com>

* fix(chat): satisfy mypy on shared-thread author and HITL lookup

Author ids from message JSON are narrowed before the profile map lookup, and a shared thread may resolve a pending approval without a user filter.

Co-authored-by: Cursor <cursoragent@cursor.com>

* fix(chat): keep private threads private when the share flag is absent

Visibility checks treat a missing contributed flag as not shared, and dashboard tests read the author-stamped HumanMessage instead of a plain dict.

Co-authored-by: Cursor <cursoragent@cursor.com>

* docs: describe projects alongside experts and teams

Record the agreed project shape: group visibility, owner-backed default context, and tasks that everyone who can open the project can see.

Co-authored-by: Cursor <cursoragent@cursor.com>

---------

Co-authored-by: jubaoliang <jubaoliang@tencent.com>
Co-authored-by: Cursor <cursoragent@cursor.com>
…2880)

An empty default model was discarded, chat chips hid which vendor a model came from, and a waiting frontend never reached people without update permission. PostgreSQL backup now explains a missing client instead of failing as an internal error.
The browser host's CDP client uses websockets.connect(), which raises
"python-socks is required to use a SOCKS proxy" when a SOCKS proxy env
var is set and the package is absent. The portable runtime's
site-packages are built from this repo's lockfile, and python-socks
was not a dependency — dev machines masked the gap because the
package happened to be manually installed in the dev venv.

Fixes #2836

Verification: uv lock --check consistent; uv export --frozen --no-dev
now emits python-socks==3.2.1.
Register Feishu channels with a durable dedup database. Publish each
channel's inbound, outbound, reconnect, and drop counters on /api/health
and the channel card. Show the checkpoint keep window and a VACUUM hint
on the memory storage page.
fix(gateway): resolve reasoning overrides on IM turns like the dashboard path
…d-checkpoint-retention

fix: surface checkpoint retention and channel health
…2920)

A finished answer was landing above its question, and the organizing hint stayed on older replies. Busy peers were also dropped when a protocol pong arrived after 20 seconds.
Once a document was in a knowledge base its folder was fixed: rename
only changes the name in place, so reorganising meant downloading,
re-uploading and re-indexing (#1839, #2905).

`POST /knowledge-bases/{kb_id}/documents/{doc_id}/move` takes a
`target_folder` ("" is the root) and moves a file or a folder within
the same base. A folder takes its subtree along in one prefix rewrite,
the same statement rename already used; both now share
`_relocate_document`. Chunks and original files are keyed by document
id, so nothing is re-indexed and no bytes move.

The target must be an existing folder. A folder cannot move into itself
or its subtree (KNOWLEDGE_MOVE_INVALID), and a name already present in
the target is refused (KNOWLEDGE_MOVE_NAME_TAKEN) rather than reported
with the knowledge-base wording of KNOWLEDGE_NAME_TAKEN. Moving to the
current folder is a no-op.

The dashboard adds "Move to…" to the card and table actions of files
and folders, with a folder tree that greys out the places the entry
cannot go.

Co-authored-by: Alison <20137720+alison-xx@users.noreply.github.com>
…2916)

* feat(cli): migrate an OpenClaw or Hermes Agent setup into an expert

`octop migrate openclaw` and `octop migrate hermes` read an existing
install where it lives and carry it into one Octop expert:

- model providers and the default model (keys from the source's .env,
  config env block, or OpenClaw's legacy auth-profiles.json);
- persona and memory files (SOUL.md, USER.md, MEMORY.md, ...; Hermes'
  "§"-delimited memory entries become paragraphs);
- skills, into the expert's workspace (Hermes' bundled skills stay
  behind);
- MCP servers, as the acting user's custom MCP servers;
- chat channels both sides have, created disabled so the old bot and
  Octop do not both answer.

Existing content is never replaced unless --overwrite is given, so a
second run is a no-op; --dry-run reports the same outcomes without
writing, and root --json prints the report as JSON. What cannot move
(scheduled jobs, SSE-only MCP servers, OAuth-only logins, platforms
without an Octop channel) is listed instead of dropped silently.

The readers live in infra/migration and produce a plan; apply.py writes
it through the repos and the expert's BackendWorkspace. OpenClaw's
config is JSON5 with $include and ${VAR}, handled by a small tolerant
parser rather than a new dependency.

* test(migration): write skill fixtures as bytes for the Windows run

Skills are copied byte for byte. The fixture wrote SKILL.md in text
mode, which is CRLF on Windows, so the byte comparison in
test_applies_every_section failed there.

---------

Co-authored-by: Alison <20137720+alison-xx@users.noreply.github.com>
Co-authored-by: Jubaoliang <jubaoliang@gmail.com>
…t dynamic registration (#2915)

Custom MCP OAuth only worked when the authorization server could be
discovered from the MCP URL and supported dynamic client registration.
Servers that expect a pre-registered OAuth app (GitHub's MCP server,
most enterprise IdPs) ended at "authentication failed" with no way in.

A streamable_http server can now carry an `oauth_client`: client id,
optional secret and scope, and optionally the authorization and token
endpoints for servers that publish no metadata. The saved client
replaces dynamic registration, explicit endpoints replace discovery, and
the token endpoint is remembered so refresh keeps working without
discovery. The probe reports `oauth.client_required` when the server
needs such a client, and the dashboard opens the credentials form with
the callback URL to register.

The client secret is write-only (responses carry `has_client_secret`),
and changing the client drops the tokens it obtained. Token requests ask
for JSON, which GitHub requires.

Co-authored-by: Alison <20137720+alison-xx@users.noreply.github.com>
Co-authored-by: Jubaoliang <jubaoliang@gmail.com>
* chore: retire versioned history after startup migration

Import old segmented messages and compatible trajectory events before starting agents. Fail closed for unreadable message history, keep the original archive, and restore normal v1 routes and writes.

* fix: render tool results with non-string media types

* feat: show scheduled checkpoint backup policy in Octop
Raise the floors to octop-harness[all]>=1.0.9 and octop-memory>=1.0.4 and
relock only that chain. Harness 1.0.9 requires deepagents>=0.7.35, which
pulls langchain 1.4.9, langchain-core 1.7.7, langgraph 1.2.20 and
langgraph-checkpoint 4.3.1.

Co-authored-by: Claude Sonnet 5.5 <noreply@anthropic.com>
#2934)

* fix: keep live chat status honest and stop websocket keepalive flaps

A finished answer was landing above its question, and the organizing hint stayed on older replies. Busy peers were also dropped when a protocol pong arrived after 20 seconds.

Co-authored-by: Cursor <cursoragent@cursor.com>

* fix: stop shared replies from overlapping and allow a chosen workspace

Someone else could send while a shared reply was still running, and a rejected send left the composer spinning. Team members that start after the host turn now keep the room locked. Create forms can set a host-root workspace, and admins see usage by user.

Co-authored-by: Cursor <cursoragent@cursor.com>

---------

Co-authored-by: jubaoliang <jubaoliang@tencent.com>
Co-authored-by: Cursor <cursoragent@cursor.com>
* feat(desktop): replace the Wails shell with an Electron shell

The desktop client now has one implementation: a frameless Electron shell that
owns the Python sidecar. The Wails v3 Go shell is gone, so there is a single
build entry point and a single release format again, and the dashboard reaches
the shell through one preload bridge (`window.octopDesktop`).

Shell (desktop/src, electron-vite; pnpm 12 + Node 24 scoped to the package):
- A privileged `octop://app/` protocol proxies `/api/*` to an OS-assigned
  loopback port. Python is spawned detached in its own process group with
  OCTOP_HOME / OCTOP_GREEN_PACKAGES / OCTOP_DESKTOP_SHELL, the portable runtime
  is SHA-256 checked before extraction, and the "local runtime is newer than
  the bundled one" guard runs before Python is spawned.
- Updates are shell-owned: manifest selection, streaming download, and a hard
  requirement that Python exits by itself with code 0 before the OS installer
  takes over. The renderer can only ask for the confirmation dialog, never name
  a URL.
- Frameless chrome follows platform convention: macOS traffic lights top-left,
  Windows/Linux caption buttons top-right, with single-sided CSS insets. The
  splash is fixed white instead of following the theme.
- Shutdown owns the sidecar: `before-quit` waits for it, and SIGINT / SIGTERM /
  SIGHUP run the same cleanup, so Ctrl+C in a dev terminal no longer orphans
  Python. `run-dev.sh` forwards the signal and bounds the wait.
- The product version resolves from the bundled portable manifest, then the dev
  runtime, and only then package.json, so release selection compares real
  versions instead of a stale placeholder.

Dashboard keeps only the Electron path: `isDesktopShell()` / `getDesktopBridge()`
in desktopBridge.ts are the single source of truth, `-webkit-app-region` replaces
the JS drag listeners, and desktop downloads fall back to an anchor click. The
settings page gains the desktop update panel (channel preference, shell-side
check, confirmation-only button).

Python side: OCTOP_DESKTOP_SHELL=1 hides in-app upgrade entry points and rejects
`octop update` / self-update APIs, with `src/octop/infra/desktop.py` as the flag.

Tooling: pnpm settings move to pnpm-workspace.yaml; `pnpm dev`, `dev:start` and
`dev:no-sandbox` all drive `scripts/run-dev.sh`. CI drops the Go, WebKitGTK and
wails3 steps and keeps producing the green zips the shell bundles.

* refactor(envs): improve error message formatting for shell-owned environment keys

Updated the error handling in the batch_save_envs function to enhance readability by formatting the error message across multiple lines. This change maintains the existing functionality while improving code clarity.

* feat(icons): add new icon files for desktop application

Introduced new icon assets in various formats (ICNS, ICO, PNG) to enhance the visual identity of the desktop application. These icons will be used across the application interface.

* feat(workflows): enhance Octop Desktop packaging and release process

Updated the GitHub Actions workflow for Octop Desktop to include new steps for staging the Electron runtime and dashboard, installing dependencies, and building native installers for various platforms. Improved artifact handling by ensuring proper uploads for different formats (dmg, exe, AppImage, deb, rpm) and updated the release naming conventions. Enhanced error handling in the release download script to accommodate local and forked repository setups.

* feat(desktop): renew the session with a per-install device credential

Desktop installs run without a password: the wizard mints one nobody ever
types, so an expired JWT used to be a dead end (/auth/login is not a path a
desktop user can take, and the only way back was the CLI).

The shell now mints a 32-byte secret on first use, stores it encrypted with
safeStorage (Keychain / DPAPI / libsecret) at <OCTOP_HOME>/desktop-device.json
with mode 0600, and trades it for a JWT when the previous one expired. The
credential never reaches the renderer: it only ever asks for a token.

- api: POST /api/auth/device/{register,token,revoke}. Only the SHA-256 digest
  is persisted (secrets row `desktop_device`); the exchange is JWT-exempt but
  requires the shell flag, a loopback peer, a constant-time digest match and a
  per-host failure throttle. Registering replaces the previous token, so a
  reinstall or a second machine takes over.
- shell: main/session/{device-credential,device-session,safe-storage-cipher}.ts
  plus three IPC channels behind the preload `session` sub-bridge; a sidecar
  that is down or refused degrades to "no session" instead of throwing.
- dashboard: renew once on 401 (business 401s are filtered first), bind the
  credential after the first authenticated success, and try a refresh on the
  login page so an expired session never lands on a password wall.
- OCTOP_ACCESS_TOKEN_TTL is no longer shell-owned. Stretching the token only
  postpones the dead end and widens the blast radius of a stolen one, so the
  TTL stays at the server default and renewal does the work instead.

Also isolates os.environ in tests/unit/test_desktop_shell.py: apply_env_file
writes past monkeypatch and leaked OCTOP_REQUIRE_SETUP_PASSWORD=0 into every
later module (test_config.py failed when ordered after it).

* chore(desktop): upgrade to Electron 45 and the async safeStorage API

Electron 33 → 45 (Node 20.18 → 24.22.0, Chromium 156), electron-builder
25 → 26 and @types/node 22 → 24. electron-vite stays on 3.1: it already
accepts vite 6, so the build toolchain needs no migration.

Electron 45 deprecates the synchronous safeStorage API (scheduled for
removal in 46), so the device credential moves to
isAsyncEncryptionAvailable / encryptStringAsync / decryptStringAsync and
`CredentialCipher` is async end to end.

That also closes a hole in the previous commit: on Linux the backend is
picked from the desktop environment rather than probed, and a headless
session silently falls back to `basic_text`, where the key is a hardcoded
passphrase. `isAsyncEncryptionAvailable` still reports true there, so the
cipher now treats `basic_text`/`unknown` as unavailable and the shell
stores the credential in the clear (0600) with a warning instead of
writing ciphertext that anyone can read.

Electron 45 also ships no postinstall: `node_modules/electron/dist/` is
populated on first use, so `electron` drops out of pnpm's `allowBuilds`
and the README documents `npx install-electron` for CI.

Verified: `pnpm typecheck`, 72 unit tests, `pnpm build`, and the binary
boots the built shell (octop:// scheme registered, windows and renderer
created).

* chore(desktop): run electron-builder with its config file

package.json still called a bare `electron-builder`, which only works
because the config happened to be discoverable. Pass
--config electron-builder.config.ts explicitly so the TS config is used
regardless of discovery rules.

* test(release): expect the Linux deb/AppImage/rpm assets

The release-link generator switched Linux from tar.gz to deb (default),
AppImage and rpm, but the test still asserted tar.gz and went red. Assert
the three real extensions per arch instead, and cover the fork behaviour:
GitHub Actions sets GITHUB_REPOSITORY, so a fork's notes must link to the
fork rather than upstream.

* feat(desktop): give the launcher its own React pages and a real error Result

The shell painted its first frame from a 30-line inline HTML splash and, when
boot could not continue, dumped a raw errno into a <pre> on a blank page. That
is what a missing portable runtime looked like to the user: a full-screen
"ENOENT: no such file or directory" with no title and no way out.

renderer/ is now a small React app of its own — react + react-dom, esbuild's
automatic JSX runtime, no antd, no Dashboard components, no plugin-react:

- splash.tsx rebuilds the boot screen (brand mark inside the ring), matching the
  Dashboard's own first paint so the swap reads as one continuous startup.
- error.html renders an antd-style Result: status glyph, headline, one sentence
  the user can act on, the technical tail folded into a collapsed 技术详情, then
  退出应用 / 复制错误信息 and the build version. Esc closes it.

The main process owns both pages: createEarlyWindow() returns a handle whose
showError() replaces the splash with the failure Result in place. The payload
travels as a base64url query parameter because the page is sandboxed — no
preload, no IPC — and shared/shell-error.ts is the encoder/decoder both sides
use, covered by tests for the round trip, URL safety, truncation and garbage
input.

Failure copy stops leaking internals: every call site now passes a sentence
plus an optional detail (runtime dir, zip digest, launcher path, port), and
dismissing the failure page quits the app instead of leaving macOS idling in
the Dock with no window.

Verified: `pnpm typecheck`, 79 unit tests, `pnpm build`, and a real launch —
the window lands on error.html with the encoded payload and renders the
Result, the copy button reports 已复制 on a real click, and window.close()
ends the process.

* fix(desktop): never store the device credential in the clear

On a host without a usable OS keychain — headless Linux, WSL, CI — the shell
wrote the 32-byte device secret as plain JSON in the data root. Mode 0600 keeps
other users out, but not backups, dotfile syncs, or anyone who copies the home
directory, and there is nothing on such a host to encrypt it against: a key kept
beside its own ciphertext would only look like encryption.

The secret no longer touches the disk there. DeviceCredentialStore holds it in
memory for the launch — renewal keeps working, the renderer still never sees it —
and the next launch starts without a credential, so that install signs in again.
That is cheap by construction: the server upserts a single `desktop_device` row,
so re-registering replaces the previous device instead of piling up rows.

Upgrading installs: a v1 file written by the old fallback is re-encrypted on the
next start when a keychain is available, and deleted otherwise. Either way its
secret is adopted for that one launch, so the upgrade itself forces no login.
`read()` no longer accepts a plaintext file at all — only `migrate()` may adopt
one, and `boot()` calls it once before the session client is constructed.

A keychain that is merely locked, or missing for one launch, no longer destroys
ciphertext it could read later: the no-keychain write path only drops files that
are not ciphertext.

Verified: `pnpm typecheck`, 86 unit tests (8 new: memory-only write, no survival
across launches, v1 ignored until migrated, re-encrypt, adopt-then-delete, empty
secret, locked keychain keeps its ciphertext, clear drops the in-memory copy),
`pnpm build`.

* chore(desktop): ignore the packaged runtime inputs

`desktop/src/resources/portable/` is not a source directory: the release
workflow runs `desktop/portable/package.sh` first, then copies the matching
`Octop-portable-<plat>-<version>.zip` in and writes `portable-version.json`
next to it (octop-desktop.yml, "Bundle portable runtime"). Committing it would
put a whole portable CPython plus site-packages in git.

`resources/dashboard` was already ignored for the same reason; the portable
sibling was simply missed. A local `pnpm package` run without both filled in
fails at boot with the shell's own error page, which is the intended signal.

* feat(dashboard): let the user reset this device's sign-in

The shell has exposed `session.revoke` since the device-credential work, but
nothing called it — the only way to drop the binding was to delete
`desktop-device.json` by hand or revoke server-side.

The desktop update panel (Settings → Advanced → Update, rendered only when the
shell is present) gains a 本机登录 section with a confirm dialog. It calls the
bridge with the JWT in hand and reports the outcome; the copy is explicit that
the current session keeps working and only renewal stops, because that is what
the backend actually does — revoking invalidates the token hash, not the JWT.

The button is hidden when `session` is missing from the bridge, so an older
shell without the method does not get a dead control.

* feat(desktop): relay WebSockets through the shell instead of the custom scheme

A page on `octop://app` could never open a socket: Chromium's upgrade bypasses
`protocol.handle`, and `onBeforeRequest` accepts `redirectURL` for a `webSocket`
request only to drop it (measured — the request is logged, the upstream never
sees a handshake). So every stream (terminal, browser, mobile, desktop, chat,
notifications, voice) silently failed under the shell.

`main/protocol/ws-relay.ts` binds a loopback port and forwards the handshake to
the sidecar, rewriting the request line, Host and Origin so the backend sees
itself. The page learns `ws://127.0.0.1:<port>/<per-launch path segment>` from a
new `wsEndpoint()` bridge call and appends `/api/...` — never the sidecar port,
which the relay re-reads per connection so a restart after an update needs no
new URL. Requests without the exact path segment (constant-time compare) or with
any Origin other than `octop://app` get 403; a sidecar that is down gets 503, an
unreachable one 504, and a backend refusal is passed through rather than being
turned into a tunnel. After 101 the two sockets are just piped, so backpressure
and cancellation survive.

The JWT still rides in the query exactly as it does in a browser: the relay
injects nothing and stores nothing, which is the point — it moves bytes, not
trust.

On the Dashboard side `resolveWsUrl()` replaces every `window.location.host`
builder, and returns the page origin when there is no bridge, so server mode and
older shells are untouched. `wsEndpoint()` is synchronous (and memoised) because
URL builders run inside render paths.

* docs(desktop): mark the pre-quit task check as a known gap

§3.4 asks the shell to ask the backend whether anything is running and to
confirm with the user before quitting. The cleanup chain itself (relay, then
Python over the grace window, then app.exit, second signal wins) is done, but
the check has no honest input yet: the backend has no in-flight task registry.
Terminals keep live PTYs in `_sessions`; browser streams, chat/Agent runs and
cron have no in-process "running" set at all, and /api/health's `agents_running`
counts loaded agents, not executing work.

Rather than ship a confirm dialog driven by a proxy-metric guess — which would
call an idle terminal "busy" and nag on every quit — this records what exists,
what the endpoint must return, and that the shell is expected to query it only
on a user-initiated quit (the signal path has no UI). Until then quitting stops
the sidecar without asking: no orphans, but work in progress is interrupted.

* docs(desktop): write down how the pre-quit task check should be built

§3.4's task check was deferred because the backend has no in-flight registry;
that note says what is missing but not how to fill it. This adds the plan so the
next person does not have to re-derive it from the codebase.

Grounded in what actually exists today: `terminal._sessions` is the only live
set; `GlobalProcessor.__call__` and `iter_turn_chunks` are two independent turn
entry points with no registry of their own; `chat/ws.py` enqueues the turn and
deliberately survives a WS disconnect, so "socket open" is neither necessary nor
sufficient; and `/api/health`'s `agents_running` counts loaded agents.

The design is one process-wide registry (`infra/runtime_activity.py`) filled at
those two seams, a read-only `GET /api/runtime/activity` gated by the same
shell-flag + loopback rule the device-token exchange already uses (deliberately
not reusing `/api/desktop/*`, which is the remote-desktop feature), and a
`quit-guard` in the shell that asks only on a user-initiated quit — never on the
installer hand-off, never on a signal — and treats a timeout or an error as
"unknown, let them leave" so quitting can never be blocked by a query.

* fix(desktop): give electron-builder the metadata deb/rpm require

The Linux job dies at `⨯ Please specify project homepage` before it writes an
AppImage or a deb/rpm, and macOS only warns (`author is missed`). Both come from
the same gap: `desktop/src/package.json` carries name/version/description and
nothing else.

`homepage` is not cosmetic for deb/rpm — electron-builder refuses to build them
without one. The value matches the endpoint the shell already talks to for
updates; `author`/`license` mirror pyproject so the two manifests agree.

* ci(desktop): retire the Node 20 actions and make the suite pass on Windows

Three warnings from the last six-platform run, none of which would ever have
turned into a failure on its own:

- `astral-sh/setup-uv@v6` and `pnpm/action-setup@v4` still declare
  `runs.using: node20`. Moved to v7 / v6, which are the newest majors that run
  on node24; `setup-uv@v10` does not exist as a floating tag, so the version
  numbers were read off the actions' own action.yml rather than guessed.
  `softprops/action-gh-release` had the same problem on the release path and
  went to v3 for the same reason.

- `runs-on: ubuntu-latest` is announced to migrate to Ubuntu 26, which would
  silently change the compiler and glibc a release is built against. Pinned to
  ubuntu-24.04.

- The Windows job failed seven tests and the workflow printed a warning and
  packaged anyway. The tests were asserting POSIX facts on Windows: 0600 file
  modes, '/'-joined paths, and SIGTERM semantics that Windows does not have
  (the tree is reaped with taskkill /T /F instead). Each is now either built
  with node:path so the separator follows the host, or carries a named skip so
  the reason is visible instead of the escape hatch. The `|| ::warning::` is
  gone; Windows has to pass.

Also promotes the unsigned-package mode out of a throwaway branch and into a
`sign` dispatch input: without a certificate electron-builder does not skip
signing cleanly on macOS, it dies mid-pipeline with a misleading "not a file",
so the skip now blanks CSC_* explicitly and drops hardenedRuntime.

* test(desktop): give resolveStaticPath a root shaped like the one it gets in production

The strict Windows run found one survivor: the fixture passed "/root/dashboard"
as the web root while `path.resolve` resolves it against the current drive on
Windows, so the confinement check refused a legitimate asset and returned null.

That is the fixture being wrong, not the implementation being Windows-hostile:
the root arrives from `app.getAppPath()` and is therefore always host-shaped.
Building it with `resolve(sep, …)` makes the test say what production says.
Checked against both path implementations, including that traversal is still
refused and that the join() expectations agree with what resolve() returns.

* refactor(dashboard): replace custom window controls with native OS buttons

This update removes the custom DesktopWindowControls component and integrates native window buttons for macOS and Windows. The application now utilizes the shell's native controls, ensuring they follow the app's theme. The changes include the introduction of useNativeWindowChrome and useWindowFullscreen hooks to manage the appearance of these controls dynamically. Additionally, the layout has been adjusted to accommodate the native buttons, enhancing the overall user experience. Tests related to the removed component have also been deleted.

* feat(desktop): floor the window at the Dashboard's desktop layout

The Dashboard drops into its mobile layout under 767px, and the sidebar
already spends 220px of the width, so a window narrower than that is one
the app has no layout for. Both windows now refuse to go below 960×600:
the Dashboard window because that is the window worth using, and the
Early Window because the splash is swapped for the Dashboard in place, so
a size the Dashboard would reject has to be rejected there too.

The default size moves into the same module instead of being two loose
numbers in `createMainWindow`, so the floor and the opening size can be
compared in one place.

* feat(dashboard): give the shell one draggable title row across the window

Dragging used to be stitched together from whatever happened to opt in:
the sidebar carried its own 32px band for the macOS traffic lights, pages
opted in through PageShell, and Chat through its title bar. The top of
the window was therefore draggable in patches, and on Windows nothing
reserved the band at all — the caption buttons were drawn over the page's
title row.

MainLayout now renders that row once, above the sidebar and the content
column, so it is unbroken across the window: 32px, `app-region: drag`,
background inherited from the shell column (which is the same colour as
the sidebar, so no seam). It stops short of the Windows caption buttons
so they stay clickable, and it disappears in full screen, where the
system hides the buttons and the page can have the pixels back.

`chromeTopBandPx` follows: the band is no longer macOS-only, because it
is now the row both platforms put their buttons in. The sidebar's private
copy of it is gone, which also stops the brand row from being pushed down
twice on macOS.

* docs(dashboard): point the full screen note at the shell title row

The band the traffic lights need is no longer owned by the sidebar, so
the comment was describing a component that does not exist any more.

* feat(dashboard): give both left rails a control you can see, and a key

The two rails could only be collapsed through a 16px pill that stayed at
`opacity: 0` until the pointer crossed the seam, and the history rail's
pill sat 3px from the nav rail's, two chevrons pointing opposite ways on
one line. Neither had a shortcut. Everything worked, nothing was
findable.

Nav rail:
- The brand row carries the collapse button (PanelLeft glyph), always
  visible and quiet until hovered, so the control lives in the rail it
  moves instead of on its edge.
- Collapsed, the mark itself is the expand button: hovering swaps the
  logo for the panel glyph without moving the hit target.
- The hover pill on that seam is gone — with two visible controls and
  ⌘B, it was a third way to do the same thing, and it was the one that
  collided with the history rail's. The rail now draws its own border.

History rail:
- Its edge pill always straddles the seam (it used to jump to `after`
  when collapsed, landing next to the nav pill).
- With the nav collapsed there is no Chat row to hang the toggle on, so
  the icon rail gets a compact one — otherwise the only ways back were a
  hover sliver and the keyboard.

Both: ⌘B / ⇧⌘B, advertised through `aria-keyshortcuts` and the tooltip.
Text fields keep the chord; contenteditable and open dialogs do not, and
IME composition is skipped. Escape now closes whichever rail is covering
the page on mobile. Reduced-motion users get the state change without the
width animation.

Toggles are also honest now: the nav toggle used to pop the history rail
open as a side effect when expanding on a chat route.

* fix(dashboard): keep the collapsed rail's history toggle on every page

The Chat row's toggle shows everywhere and reaches the history rail from
any route (opening it from /experts navigates to /chat first). The
collapsed rail's equivalent was gated to chat routes, which quietly took
the only visible control away on every other page.

* fix(dashboard): dock the collapsed rail's history toggle below the nav scroller

The toggle was appended to the end of the scrolling nav body. The nav list is
taller than the rail in a default 800px window, so the button landed past the
fold and only a scroll to the very bottom revealed it — the control was there,
just never on screen.

Dock it under the scroller instead, above the user footer: always visible,
still outside the nav flow, and centred on the 56px rail instead of 3px off.

* fix(dashboard): stop emitting an "undefined" class on the rail's brand row

The row asked for `styles.sidebarBrand`, a class that never existed in
Sidebar.module.less, so CSS Modules handed back undefined and every render
wrote class="undefined octop-desktop-drag". The styling already lives inline
and the drag class comes from desktopChrome, so the extra lookup only ever
produced noise in the DOM.

* fix(dashboard): give the collapsed rail's icons a name and a current page

Collapsing the rail drops every row label, and the icon buttons carried
neither an aria-label nor aria-current — a screen reader read a column of
identical unnamed buttons while the hover tooltip did all the work.

Name each icon from its row label and mark the active one as the current
page. The label stays the action-free row name so the tooltip and the
accessible name agree.

* fix(dashboard): answer a missing model with the setup prompt, not a red cross

"未配置可用模型" reaches the chat page as a failed agent start, so the empty
state rendered as antd's error Result: a red cross, "专家启动失败", and the raw
backend sentence ending in "然后重新启用此专家" — the alarm reserved for a
broken agent, in front of a first-run user who has done nothing wrong.

ModelConfigEmpty already says the same thing kindly, with the permission check
and the right call to action, but the only path that reached it required the
agent to have started first. Route the model-config failures there instead,
and only when the agent actually failed and no bridge is down: a disconnect is
still the state to act on, and last_error may just be a leftover.

* fix(dashboard): name the problem on an expert card instead of clipping a sentence

An expert card renders its error in one ellipsised 391px line, so the model
config sentence was cut at "…然后重新启用此专…" — losing the one instruction it
carried, while the card's own "去配置模型" button sat right underneath saying
the same thing.

Keep the full sentence in the tooltip and give the row the short form: model
config errors only have to name the diagnosis. Everything else still renders
at full length.

* fix(dashboard): tell an expert-less user apart from one whose expert is parked

The history rail lists only experts that can chat, so an expert waiting on a
model leaves the rail empty — and the empty state answered that with "从专家列表
选择模板,快速创建你的第一个 AI 专家" plus "去创建专家", pointing a first-run user
at creating something they already have.

Pass the count of not-yet-chat-ready experts down and answer that case with
"你的专家暂时都不能对话" and a link to the experts page. Users who own nothing
still get the create-first-expert nudge.

* fix(i18n): call it 专家 in the Chinese error strings too

The dashboard has been calling these things 专家 for a while — apiErrors says
"专家启动失败。", "专家正忙。", "未找到专家。" — but the server-side Chinese
catalogue still said "Agent", and the server's message is what reaches the
user, so a failed start surfaced as "Agent 启动失败。" in a toast.

Align the four expert lifecycle errors with the wording the UI already uses.
Slash-command vocabulary and product names (Agent Mail, Agent ID) are left
alone; only the messages a Chinese user reads about their own expert change.

* feat(desktop): make the loading and failure pages say what is happening

The splash was an 88px ring, a 60px icon and one gray line — about 7% of
a 1080x720 window, with no indication of what was being waited on or for
how long. It now carries the brand mark, the wordmark, one honest status
line ("正在准备本地服务…"), an indeterminate 200x3px bar that keeps
moving, and the version the shell is starting, so a slow boot never looks
like a frozen window.

The failure page was a generic ✕, a title, one sentence and a choice
between "quit" and "copy the error". Quitting was the only real option,
yet most boot failures are transient — a busy port, a sidecar that lost a
race — and the fix was "quit, find the icon, open it again". It now leads
with 重试启动 (app.relaunch + exit, so the retry starts from a clean
process), demotes 退出应用, and keeps the technical detail and the copy
action as secondary links below the fold.

The retry needs an IPC channel, so the shell's own pages get their own
single-method preload (preload/early.ts) rather than the Dashboard's
bridge: window.octopShell.restart, nothing else, and the button hides
itself when that bridge is absent.

EARLY_IPC lives in shared/early-ipc.ts instead of shared/ipc-contract.ts
on purpose. Both preload entries importing one module made Rollup emit it
as a shared chunk, and a sandboxed preload can only require electron and
Node built-ins — `require("./chunks/…")` throws, the bridge never
registers, and window.octopDesktop silently disappears. One module per
entry keeps every preload a single self-contained file.

* feat(dashboard): start the web app with the same splash as the shell

The first paint was an 88px spinner ring with a 60px vertical logo dropped
inside it — 60px of artwork inside an 88px circle with 14px of padding, so
the wordmark inside the logo sat on the ring itself — plus one line of gray
"splash" text. It also swapped assets by theme, which meant a second copy
of the brand to keep in sync with the shell.

It now uses the shell's composition verbatim: the 64px mark, the wordmark
as text, one honest line about what is being waited on ("正在加载界面…"),
and a 200x3px indeterminate bar. Both sides of the launch — Electron's
splash, then the Dashboard's boot screen — are now the same picture, so the
hand-off reads as one continuous startup instead of two different apps.

The mark is a single asset (favico.svg) because the tile carries its own
background; the white twin is gone. Theme still comes from data-theme so a
stored preference wins over the OS, and reduced-motion users get a static
bar instead of a sweep.

* feat(dashboard): show a crash the way the rest of the app fails

The boundary rendered antd's stock `<Result status="error">`: a red ✕ in a
circle, and the raw exception as the subtitle — so a tab that lost a chunk
was greeted by "Failed to fetch dynamically imported module". It also had
nothing to do with the three other failure surfaces (offline panel, 404,
boot splash), which all speak in mascot + one sentence.

The fallback now uses the same shape: mascot, a title, one sentence, the
actions, and the exception folded into a "技术详情" disclosure that is
closed by default. It still reports what happened — just to whoever opens
it rather than to everyone.

The buttons are plain rather than antd's. This component renders above the
ConfigProvider, so an antd Button here inherits none of the app's theme:
measured in the running app it came out stock blue with the stock prefix,
next to a rose-branded UI. A crash page is the last place that should look
like a different product — and the last place worth depending on the theme
layer, which may be exactly what broke.

* feat(dashboard): let the offline page look like the product waiting

The PWA offline shell was hard-coded dark — light-theme users got a black
page — used the vertical lockup where the wordmark was already in the
heading, painted the heading itself in the accent color, and used a pill
button that exists nowhere else in the app.

It now shares the boot splash's composition (mark, title, one sentence,
one brand button, soft glow) and follows the theme the user actually
stored, read from localStorage the same way the app does, with the OS as
the fallback. Still zero dependencies: this page has to render when
nothing else will load.

* fix(desktop): make the whole splash/error surface the window handle

Both shell pages are chrome-less — the titlebar is hidden, so the only way
to move the window is a CSS drag region — and both offered exactly one: a
fixed 32px strip across the top. That is a strip you cannot see, on a page
whose entire content is centered in the middle of the window, so the
natural gesture (grab the page somewhere near the top) misses it and the
window does not budge.

The drag region now sits on `body` and covers the page, with the handful
of interactive things opting out through `no-drag`: buttons, the details
summary, links, inputs and the detail `<pre>` (which stays selectable).
`app-region` inherits, so one declaration reaches every nested node —
verified in the running app: `.result__title` computes to `drag`,
`.result__button` and `.result__summary` to `no-drag`.

The fixed strip is gone; it was also the one structural difference from
the Dashboard's drag rows, which are in flow and have always worked.

* fix(dashboard): hold the boot mark still while it waits

Both waiting screens breathed — the desktop splash and the mark on the web
boot page — scaling to 0.96 and back on a 2.4s loop. On a retina display a
subpixel scale is exactly where a 64px logo goes soft, so the thing people
stare at longest was the thing that looked worst. The progress bar underneath
already says the app is alive; the mark does not need to pulse as well.

* feat(dashboard): give each rail its own collapse control

Two panel-collapse glyphs sat one above the other in the top-left corner:
the nav's own at the end of the brand row, and a second one hung inside the
"对话" nav item that folded the conversation rail. Same icon, 56px apart,
and neither said which panel it closed — you had to try one to find out.

Each rail now folds from its own header, where ChatGPT, Claude and deepseek
all put it: the nav's stays in the brand row, the conversation rail's moves
to the right of its search field. Both are 28px, share the hover fill and
the focus ring, and sit at the top-right of the panel they belong to, so
the control reads as "this panel" without a tooltip.

The nav row keeps its own layout back (no reserved padding for a button that
is no longer there).

Collapsed, the conversation rail has no header left to carry its control, so
the seam pill (`RailEdgeControl`) now stays painted instead of appearing on
hover only — otherwise the only way back was a 16px sliver nobody crosses on
purpose, plus the dock in the collapsed icon rail.

Web and desktop differ only in what may be dragged: in the shell the brand
row is a window handle, and its button still opts out with `app-region:
no-drag`. The rail header is not part of any drag region, so the new control
needs no opt-out — verified on the running client (computed `app-region` is
`no-drag` on the nav toggle, `none` on the rail one).

* fix(dashboard): run the rail seams to the window's top edge

The shell reserves a 32px band at the top for the native window buttons, and
it did that as a flow row above everything else. Every column therefore
started at y=32, which meant each rail's divider began with a blunt 1px tick
32px down — a line hanging in blank space, and the only thing that revealed
the band at all.

The band now floats over the columns instead of pushing them down: the rails
paint their surface and their seams from the window's top edge, the way
ChatGPT, Claude and deepseek draw theirs, and no junction is left to look at.
Nothing moves: every column insets its own content by the same 32px (published
as --octop-shell-top-band), so the band still owns exactly the strip it owned
before — empty in all of them — and stays one unbroken drag handle across the
window, above the rails (z-index 40, under every overlay at 100+) and clear of
the Windows caption buttons.

Full screen, mobile and the browser all resolve the band to 0, so the seams
simply reach the top and nothing is inset.

* feat(dashboard): fold both left rails from their seam

Each left column answered to a different control: the nav to a
`PanelLeftClose` glyph in the window's top row, the history rail to a
second glyph beside its search field, and a hover-only pill on the
divider in between that belonged to neither. Three ways to close two
panels, and the pill was an 18px sliver at 0 opacity — you found it by
accident or not at all.

Both now fold from one shape: a capsule straddling the rail's own seam,
centred on the line that actually moves. Quiet at rest (0.6) so two rails
side by side do not read as a strip of buttons, crisp under the pointer,
and always painted when its panel is collapsed — that state has no other
way back, so the handle is the way back.

The two-layer states are settled by position and ink, not by tooltips
alone:

- both open: one capsule per seam, each centred on its own divider;
- history closed: its handle lands on the nav's divider, where the nav
  keeps one too. They stack 40px apart (nav above, history below) rather
  than overlap, and only the collapsed one is painted bright — the faint
  handle closes a panel, the bright one brings a panel back;
- both closed: the same pair, and the history handle still opens the
  whole workspace (it broadcasts, so the nav returns with it) while the
  nav handle restores just the icon rail.

The header glyphs are gone: the top row keeps only its height (the drag
band and the traffic lights still own that strip), and the search field
gets its full width back. The nav's seam handle lives in a host beside
the rail, since the rail clips its own width animation.

* fix(desktop): reap the whole dev process tree on shell exit

Ctrl+C previously forwarded SIGTERM to Electron and, after a watchdog
window, SIGKILLed only the Electron main process. Python runs in its own
detached process group, so a hung or unresponsive shell could leave the
backend alive holding the database open. Builds before launch were not
supervised at all.

run-dev.sh now hands the build and the app to scripts/dev-process.mjs:

- the managed command runs in its own process group, so terminal signals
  reach the supervisor instead of racing with the app;
- the tree is sampled from ps and tracked by PID plus start time, keeping
  detached descendants after their parent is gone and rejecting reused
  PIDs; a failed sample is skipped rather than stopping a healthy app;
- the first signal sends Electron exactly one SIGTERM so its own sidecar
  shutdown runs, then cleans observed survivors even if Electron exits
  normally or crashes; after 8s the rest are killed and confirmed within
  2 more seconds, and a second signal skips the grace window;
- explicit stops exit 0, build/app failures keep their status, and
  unconfirmed cleanup reports 1 instead of claiming success.

Option parsing stays ahead of the supervisor so --help and bad flags never
need a process table.

* fix(desktop): let a bare 'pnpm dev' reach the supervisor again

macOS ships bash 3.2, which reports "${ORIGINAL_ARGS[@]}" as an unbound
variable under 'set -u' when the array is empty. A plain 'pnpm dev' has no
arguments, so the re-exec line aborted with

  scripts/run-dev.sh: line 53: ORIGINAL_ARGS[@]: unbound variable

and the shell exited before starting anything. Linux shells expand the empty
array silently, so CI would never have caught it.

Expand the array only when it has elements, and add a regression test that
runs the real script with no arguments under a trimmed PATH so it stops at
the pnpm check instead of building.

* feat(dashboard): fold all three columns from their seams

Give the two left columns one hover-triggered handle each, straddling the
divider they share with the next column, and take the copies back out of
the column headers.

Placement is derived, not measured: the host column is relative and the
capsule sits at `left: 100%` with `translate(-50%)`, so it lands on the
seam and follows it when the column folds — the arrow flips with the state
(chevron-left to fold, chevron-right to reopen) and the handle ends up on
the new edge with no second rule. Nothing about it lives in the content.

The 20x44 capsule is its own hit area and stays transparent until hovered
(opacity 0 is still hit-testable, so no invisible overlay sits on the
seam and the column's resize handle either side stays usable). Folded, the
handle stays painted: it is that column's only way back.

Both handles carry a small offset off the seam's vertical centre
(+/-SEAM_HANDLE_STEP) so that when the history rail is closed — its seam
collapses onto the nav's — they stack instead of overlapping, which also
removes the old per-state `stack` prop and the shared-seam bookkeeping in
Sidebar.

ChatSidebarPanel no longer owns a fold control at all, so its railToggle
test and the RailEdgeControl it rendered are gone; the broadcast constant
moves to chatRailEvents.ts, next to its consumer.

* refactor(dashboard): unify desktop chrome height and streamline drag regions

Updated the desktop chrome height to a consistent 58px across the application, ensuring alignment with native window controls. Removed unnecessary drag regions from various components, consolidating the drag functionality into a single bounded area. Adjusted styles and layout to maintain visual consistency and improve usability, particularly in fullscreen mode. Enhanced tests to validate the new layout behavior and ensure proper integration across platforms.

* feat(logging): implement desktop logging functionality

Introduced a new logging system for the desktop application, allowing for better tracking of events and errors. The logs are stored in `<OCTOP_HOME>/logs/desktop.log`, providing a centralized location for diagnostics. Updated various components to utilize the new logging methods, replacing console outputs with structured log entries. Added tests to ensure the logging functionality works as expected, including log rotation and error handling.

* feat(authentication): implement local account claim flow for existing users

Added a new document outlining the implementation plan for claiming existing local accounts when `OCTOP_HOME` already contains users. This addresses the scenario where users with pre-existing data are directed to the login page after installing a new desktop version. The document specifies the necessary API endpoints and security measures, although the actual implementation is yet to be completed. Updated `DESKTOP_ARCHITECTURE.zh.md` to reference this new functionality.

* feat(docs): add integration and task check documents for Octop desktop

Created new documentation for Octop's Electron integration, detailing the embedding of the green portable zip and the necessary steps for setup and execution. Additionally, added a document outlining the implementation plan for a pre-quit task check, which prompts users if there are ongoing tasks before exiting the application. These documents enhance the understanding of the desktop architecture and improve user experience during application shutdown.

* refactor(logging): restructure desktop logging system and update documentation

Reorganized the desktop logging functionality to store logs in a dedicated directory: `<OCTOP_HOME>/logs/desktop/desktop.log`. Enhanced log rotation to occur at local midnight and at 100 MiB, with older logs being gzipped and purged based on retention settings. Updated related documentation to reflect these changes, including paths in `README.md` and implementation details in `DESKTOP_ARCHITECTURE.zh.md` and `LOCAL_ACCOUNT_CLAIM.zh.md`. Added tests to ensure the new logging behavior works as intended.

* feat(dashboard): add DesktopWindowDragBand component for improved window dragging

Introduced the DesktopWindowDragBand component to enhance the window dragging experience across different platforms. This component conditionally renders a drag region based on the desktop chrome style and fullscreen state. Updated MainLayout to utilize the new drag band, ensuring it integrates seamlessly with existing layouts. Added comprehensive tests for the DesktopWindowDragBand to validate its behavior in various scenarios, including fullscreen mode and different operating systems.

* feat(authentication): implement local account functionality for desktop users

Enhanced the authentication flow to support local accounts in the desktop application. Introduced a mechanism to create and sign in to a local account named "local," which bypasses the login screen. Updated JWT handling to differentiate between local and password accounts, ensuring proper session management. Modified the setup process to allow the addition of a local account alongside existing users. Added relevant tests to validate the new functionality and updated localization files for user-facing strings related to local account actions.

* feat(dashboard): enhance theme handling and improve UI consistency

Updated the dashboard's theme management to prioritize desktop shell preferences over stored values, ensuring a seamless user experience. Introduced functions to read and remember theme preferences, allowing for dynamic adjustments based on URL parameters. Modified CSS styles for better visual consistency across light and dark themes, including background and text color adjustments. Updated splash and error pages to share a common theme script, ensuring consistent theming during initial loading. Enhanced tests to validate new theme behaviors and ensure proper integration with the desktop application.

* feat(dashboard): update logo assets and improve theme consistency

Replaced the favicon with a new cropped logo asset for both light and dark themes, ensuring a unified appearance across the dashboard. Adjusted CSS styles to remove unnecessary properties and enhance visual consistency. Updated tests to validate the new logo integration and confirm that the splash and error pages utilize the same logo asset. Additionally, refactored the renderer configuration to streamline the build process for the desktop application.

* feat(dashboard): introduce RailEdgeControl and SplitSeamHandle components for improved navigation

Added the RailEdgeControl component to manage the navigation rail's edge interactions, allowing for seamless expansion and collapse of the sidebar. Introduced the SplitSeamHandle component to provide distinct controls for collapsing the navigation and expanding the history rail, enhancing user experience. Updated styles for better visual consistency and integrated new components into the MainLayout. Removed the deprecated RailSeamHandle component and its associated tests, ensuring a cleaner codebase. Added tests for the new components to validate their functionality and interactions.

* refactor(dashboard): remove SplitSeamHandle and enhance RailEdgeControl functionality

Deleted the SplitSeamHandle component along with its styles and tests to streamline the codebase. Enhanced the RailEdgeControl component to manage sidebar interactions more effectively, including improved hover effects and pointer event handling. Updated styles for better visual consistency and integrated new chat rail toggle functionality within the Sidebar component. Adjusted tests to validate the new behavior and ensure proper integration across the application.

* feat(dashboard): enhance sidebar collapsed navigation and styling

Improved the sidebar's collapsed navigation by introducing new styles and components for better user interaction. Updated the Sidebar and SidebarCollapsedIconNav components to support a more visually appealing collapsed state, including refined button styles and hover effects. Adjusted the layout to ensure proper alignment of icons and badges within the collapsed view. Enhanced tests to validate the new functionality and ensure consistent behavior across different screen sizes.

* fix(dashboard): adjust brand mark positioning in sidebar collapsed state

Modified the transform property of the brand mark in the sidebar's collapsed state to improve alignment. This change ensures a more visually appealing presentation of the logo when the sidebar is minimized.

* feat(mac-privacy): implement macOS privacy usage descriptions and localization

Added functionality to manage macOS privacy usage descriptions for microphone, speech recognition, screen capture, and local network access. Introduced a new module for handling localization in English and Chinese, ensuring compliance with macOS requirements. Updated the Electron builder configuration to include privacy-related information and write localization files during the packaging process. Added tests to validate the new privacy features and localization functionality.

* feat(dashboard): implement desktop update confirmation and localization enhancements

Added a new confirmation dialog for desktop updates, allowing users to confirm installations directly from the settings page. Updated the localization files for English and Chinese to include new strings related to the update process. Refactored the update handling logic to ensure the renderer cannot specify package URLs, enhancing security. Introduced tests for the DesktopUpdatePanel component to validate the new confirmation flow and user interactions.

* feat(dashboard): integrate desktop shell update checks into useUpdateStatus hook

Enhanced the useUpdateStatus hook to include checks for updates via the desktop shell, allowing for a more streamlined update process. Added a new test case to validate the behavior when the desktop shell is present. Updated the DesktopUpdatePanel component to utilize the new hook for fetching update status, ensuring a consistent user experience. Adjusted related tests to reflect these changes and improve overall functionality.

* feat(supervisor): improve process cleanup and temp directory handling

Introduced a new `removeTemp` function to handle the removal of temporary directories more robustly, addressing potential issues with busy or locked files. Updated the `SidecarSupervisor` class to wait for process exit before attempting to delete directories on Windows, ensuring proper cleanup. Refactored tests to utilize the new cleanup function, enhancing reliability in test scenarios.

* refactor(dashboard): simplify RailEdgeControl styles and remove unused resizing logic

Removed unnecessary resizing styles and props from the RailEdgeControl component to streamline the codebase. Updated the associated LESS file to eliminate redundant hover effects and improve overall clarity in styling. This change enhances maintainability and reduces complexity in the component's implementation.

* chore(electron): update icon configuration and replace icon asset

Added a comment in the electron-builder configuration to clarify the use of full-bleed opaque icns. Updated the icon asset located in resources to enhance visual quality. This change ensures better compatibility with macOS Finder display requirements.

* feat(electron): enhance DMG configuration and improve symlink handling

Updated the electron-builder configuration to include a custom DMG background and icon settings for better macOS compatibility. Enhanced the runtime extraction process by implementing safe symlink target checks and restoring symlinks from the portable zip, ensuring proper executable permissions. Added tests to validate the new symlink handling functionality and improve overall reliability.

* refactor(dashboard): remove device login functionality and clean up localization files

Removed device login related strings from English and Chinese localization files to streamline the user interface. Updated the DesktopUpdatePanel component by eliminating the reset login functionality and associated tests, enhancing overall clarity and maintainability of the codebase.

* refactor(dashboard): simplify Chat background styling and enhance DesktopUpdatePanel layout

Removed the radial gradient background from the Chat component, reverting to a solid background for improved clarity. Updated the DesktopUpdatePanel to apply a constrained panel style, enhancing layout consistency across settings pages. Added a new panelConstrained class to manage maximum width, improving responsiveness.

* feat(update): enhance update status handling and introduce channel head logic

Updated the useUpdateStatus hook to accurately reflect the latest version available, including the channel head logic for stable and beta versions. Added a new test case to verify behavior when no updates are available. Refactored the update coordinator to fetch the update manifest and determine the highest tag based on user settings. Improved documentation for clarity on version handling.

* feat(runtime): enhance portable runtime handling and extraction process

Updated the workflow for managing the portable runtime in the Electron application. Improved the extraction logic to handle platform-specific requirements, ensuring that the runtime is correctly expanded and utilized based on the operating system. Enhanced documentation in the README and related files to clarify the runtime structure and installation paths. Added tests to validate the new runtime detection and extraction functionality, ensuring robust handling across Windows, macOS, and Linux environments.

* feat(installer): add custom checks for running processes and enhance portable runtime extraction

Implemented a custom check in the NSIS installer to prevent installation if the application is already running, providing user feedback in both English and Chinese. Added logic to extract the portable runtime during installation, ensuring proper handling of the runtime files. Updated the .gitignore to allow the build directory for the installer, improving build management.

* feat(installer): enhance installation process with taskbar pinning and desktop shortcut options

Updated the NSIS installer to include user options for pinning the application to the taskbar and creating a desktop shortcut during installation. The taskbar pinning option is presented before file copying, while the desktop shortcut creation is confirmed on the finish page. Silent installations will still create the desktop shortcut unless specified otherwise. Improved uninstall process to remove taskbar pins and shortcuts appropriately, ensuring a cleaner removal experience.

* feat(workflow): handle unsigned packaging for macOS in workflow_dispatch event

Updated the GitHub Actions workflow to package unsigned installers when the CSC_LINK secret is unset during a workflow_dispatch event. This change prevents build failures related to code signing and ensures a smoother packaging process. Additionally, added comments to clarify the logic for handling signing conditions.

* fix(desktop): keep manual package dispatches unsigned

Manual workflow_dispatch was still asking electron-builder to sign, which aborts on macOS when no certificate is configured. Branch dispatches now skip signing; a dispatch on a v* tag still signs.

Co-authored-by: Cursor <cursoragent@cursor.com>

* fix(installer): declare the taskbar page with Page custom

MUI2 does not define MUI_PAGE_CUSTOM, so makensis aborted both Windows installers.

Co-authored-by: Cursor <cursoragent@cursor.com>

* feat(tray): implement system tray functionality for Windows

Added support for a system tray icon on Windows, allowing users to access the application from the notification area. Implemented context menu options for showing the window and quitting the application. Enhanced the installation process to include checks for the tray icon and updated related logic to ensure proper behavior when the application is minimized or closed. Updated health check timeout to accommodate longer cold imports of the bundled runtime.

Co-authored-by: Cursor <cursoragent@cursor.com>

* feat(installer): enhance Python bytecode compilation during installation

Updated the NSIS installer to compile Python bytecode into the designated cache directory during installation, improving the initial launch experience. The installer now handles potential compilation failures gracefully, allowing the application to function while ensuring bytecode is compiled on first launch if necessary. Additionally, clarified the retention of user data during uninstallation, preserving the cache directory along with other user configurations.

* fix(installer): update uninstallation process to remove bytecode cache

Modified the uninstallation logic in the NSIS installer to delete the Python bytecode cache directory (`OCTOP_HOME\pyc`) while retaining user data such as the database, workspace, and configuration files. This ensures a cleaner uninstallation process while allowing for bytecode recompilation on the next installation. Updated related documentation to reflect these changes.

* fix(installer): leave customFiles macros to electron-builder

The portable zip is a precompressed resource, so electron-builder already defines customFiles_<arch>. A second definition aborts makensis.

Co-authored-by: Cursor <cursoragent@cursor.com>

* fix(installer): write install steps into the details list

textonly only updated the status line above the progress bar, so the details box stayed empty.

Co-authored-by: Cursor <cursoragent@cursor.com>

* fix(desktop): put window controls on their own row and show error text

Windows keeps a full system title row and the standard menus, while macOS traffic lights stay at their usual size. User admin failures show the message instead of the raw JSON, and local sign-in copy says 本地账户.

Co-authored-by: Cursor <cursoragent@cursor.com>

* fix(dashboard): keep extra tabs in the Tabs overflow menu

The tab row grew with its labels and the page clipped the tail, so the more menu never appeared.

Co-authored-by: Cursor <cursoragent@cursor.com>

* fix(desktop): make the Windows title bar transparent and keep the tray icon

The opaque caption hid the page, the packaged app had no ico for the notification area, and About only showed the version.

Co-authored-by: Cursor <cursoragent@cursor.com>

* fix(desktop): start the Windows dev dashboard past the boot screen

Node rejects spawn of vite.cmd, and pnpm does not expose dayjs, katex, or @ant-design/icons until they are direct dependencies.

Co-authored-by: Cursor <cursoragent@cursor.com>

* feat(desktop): keep the Windows window and draw its menu in the page

The splash window loads the dashboard in place. File, Edit, View, and Help stay on that bar in fullscreen, while the native caption buttons hide and the loading and error pages can be dragged from the top strip.

Co-authored-by: Cursor <cursoragent@cursor.com>

* fix(desktop): line the loading mark up with the wordmark

The red circle sits left in the mark, so both boot screens nudge it right onto the text below.

Co-authored-by: Cursor <cursoragent@cursor.com>

* fix(desktop): satisfy the menu index typecheck

Indexing the menu tuple can be undefined under strict checks, which failed the desktop package build.

Co-authored-by: Cursor <cursoragent@cursor.com>

* fix(desktop): drag Windows only from the caption bar

The page drag strip stays macOS-only, and the boot line says the app is opening.

Co-authored-by: Cursor <cursoragent@cursor.com>

* refactor(tests): improve formatting and readability in test files

Updated test files to enhance code readability by adjusting formatting, including consistent indentation and line breaks. This includes changes in the WindowsAppMenu, SidebarCollapsedIconNav, and MainLayout tests, among others.

Co-authored-by: Cursor <cursoragent@cursor.com>

* feat(desktop): enable dragging macOS windows from the drawer header

Added CSS rules to allow dragging of macOS windows specifically from the drawer header, ensuring that the title-bar drag strip remains functional. Updated tests to verify this behavior.

Co-authored-by: Cursor <cursoragent@cursor.com>

* refactor(build): streamline Linux packaging by removing AppImage support

Updated the CI workflow and documentation to reflect the removal of AppImage from the Linux build targets, focusing on deb and rpm packages instead. Adjusted related scripts and tests to ensure consistency with the new packaging strategy.

* fix(desktop): hide the Windows loading-page menu and keep reload on client routes

The splash was showing the native menu bar, and reloading a frontend route such as /chat served an empty page.

Co-authored-by: Cursor <cursoragent@cursor.com>

* fix(desktop): keep the Windows caption above drawers

Drawers mount on the body and were painting over the File / Edit / View / Help row.

Co-authored-by: Cursor <cursoragent@cursor.com>

* refactor(build): optimize packaging by pruning unnecessary files and updating dashboard handling

Introduced a new script to remove bloat from the packaged site, including debug symbols and test directories. Updated the CI workflow to reflect changes in how the Dashboard is served, ensuring it is now sourced directly from the portable tree without duplication. Adjusted related configurations and documentation accordingly.

* feat(build): introduce dual packaging variants for desktop and portable applications

Added support for two packaging variants: 'lite' for public network access and 'full' for intranet use, which includes additional components like desktop, OCR, and local embedding. Updated CI workflows, scripts, and documentation to reflect these changes, ensuring proper naming conventions and asset handling for both variants. Enhanced tests to verify the correct prioritization of package names based on the selected variant.

* feat(portable): update macOS dependency overrides for onnxruntime and opencv-python

Enhanced the `_common.sh` script to pin `onnxruntime` to version 1.23.2 for macOS 13.0 compatibility and added `opencv-python` version 4.11.0.86 for Intel architecture. Updated README to reflect these changes and clarified platform-specific overrides. Adjusted unit tests to include `darwin-arm64` as an override platform.

* feat(dependencies): add shapely as a dependency for knowledge-ocr and update version to 2.2.0

Included shapely in the knowledge-ocr package dependencies to ensure compatibility with Windows ARM64. Updated the version to 2.2.0, which provides wheels for all portable targets. Adjusted packaging scripts to exclude opencv-python and pyclipper for Windows ARM64 due to the absence of available wheels. Updated related documentation and tests to reflect these changes.

* feat(desktop): unify caption overlay behavior for Windows and Linux

Updated the desktop application to treat Windows and Linux consistently regarding the caption overlay. Adjusted comments and documentation to reflect that both platforms share the same row for the menu and window buttons. Enhanced tests to verify the new behavior across both platforms, ensuring a cohesive user experience.

Co-authored-by: Cursor <cursoragent@cursor.com>

* feat(auth): enhance device token generation with MFA and password versioning

Updated the device token generation logic to include Multi-Factor Authentication (MFA) and password versioning. The changes ensure that the generated token incorporates the user's MFA and password versions, improving security and user session management. This enhancement aligns with the overall goal of strengthening authentication processes within the application.

* refactor(chat): simplify padding and update comments in ChatTitleBar styles

Refactored the CSS for the ChatTitleBar by simplifying the padding properties and removing unnecessary complexity related to window controls. Updated comments for clarity regarding layout behavior. Adjusted tests to reflect these changes, ensuring consistency in style expectations.

* feat(desktop): implement desktop shortcut creation for Linux installations

Added scripts to create and manage desktop shortcuts for the Linux version of the application during installation and removal processes. The `after-install` and `after-remove` scripts ensure that shortcuts are placed on the user's desktop and removed appropriately, enhancing user accessibility. Updated documentation to reflect these changes and included tests to verify the functionality of the new shortcut management system.

* feat(desktop): implement flexible overlay layers for popups and menus

Introduced a new structure for managing overlay layers in the desktop application, allowing popups and menus to be positioned correctly without overlapping. Added `octop-chrome` and `octop-stage` elements to the HTML layout for better organization of UI components. Updated CSS to ensure proper flex behavior and positioning of elements. Enhanced tests to verify the new overlay functionality and layout adjustments.

* feat(desktop): add Linux window controls with square buttons

Implemented square caption buttons for Linux in the desktop application, allowing users to minimize, maximize, and close windows directly from the application interface. The buttons are styled to match the application's theme, with the close button turning red on hover. Updated the layout and styles to ensure proper integration with existing components. Added tests to verify functionality and appearance across different scenarios.

* feat(vscode): enhance .gitignore and add custom CSS data support

Updated .gitignore to exclude all files in the .vscode directory except for settings.json and css-custom-data.json. Added css-custom-data.json to provide custom data for CSS properties specific to Electron/Chromium. Created settings.json to reference the cust…
Co-authored-by: Cursor <cursoragent@cursor.com>
@jubaoliang
jubaoliang merged commit cd17e8d into main Nov 11, 2026
14 of 15 checks passed
@jubaoliang
jubaoliang deleted the release/1.0.3b5 branch November 11, 2026 06:04
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

9 participants