Platforms: macOS, Windows, Linux, phone
Pulse was born as an app for macOS on Apple Silicon. Starting with 0.25.0, installers are being built for macOS on Intel, Windows and Ubuntu. Below is honest: what works everywhere, what is only on macOS so far and why a different approach is needed for Android.
What's going on
| System | File | How is it going |
|---|---|---|
| macOS, Apple Silicon | Pulse-<version>-arm64.dmg |
GitLab CI macos arm64 on Mac Apple Silicon; locally npm run pack |
| macOS, Intel | Pulse-<version>-x64.dmg |
GitLab CI macos x64 on Intel Mac; locally npm run pack:mac-intel |
| Windows 10/11, x64 | Pulse-<version>-x64-setup.exe, plus zip without installation |
GitLab CI windows x64 on Timeweb: INSTALLERS=1 or ▶ button |
| Ubuntu 22.04+ and derivatives, x64 | Pulse-<version>-x86_64.AppImage, Pulse-<version>-amd64.deb |
GitLab CI linux x64 on Timeweb the same rule; locally npm run pack:linux |
GitHub Actions are disabled. After connecting Mac runners with tags macos and
macos-intel set an unclassified project variable PULSE_MAC_RUNNERS_READY=1
in GitLab CI/CD Variables without the Protected flag, so that it is also available in MR. Then GitLab itself launches macos arm64, then macos x64. Both tasks are required for main and M.R.; if the runner goes offline, the job will wait and the pipeline will not complete. Until the variable is set, both Mac jobs are manual and the pipeline does not run. It helps to register each Mac as a separate standard user.
scripts/macos-runner.sh. On Intel you need x64 Node/npm and native x64 agent packages; flag --x64 does not install them on an ARM machine.
Windows and Linux are built with main and don't wait for Mac: pipeline with INSTALLERS=1
(Run pipeline or night schedule) or the ▶ button. General runner concurrent = 1
completes tasks one at a time. After launching, check the status of the task itself,
SHA256SUMS and file PACKAGE.txt. EXE/ZIP, AppImage/deb and both DMGs are stored in the GitLab Package Registry. The Codex Windows binary is taken from a fixed npm package with SHA-512 verification, and node-pty contains ready-made Windows prebuilds. Cross-building Windows confirms the package contents, but not the launch of the application on Windows.
The signed release is checked separately on real Windows, after assembly there. Once the certificate and key access method are chosen, they must come from protected assembly secrets, without a key file in the repository. Both files require a valid Authenticode signature from the same expected publisher:
npm run pack:win
powershell.exe -NoProfile -ExecutionPolicy Bypass -File .\scripts\verify-windows-signature.ps1 `
-Installer .\dist\Pulse-<version>-x64-setup.exe `
-Application .\dist\win-unpacked\Pulse.exe `
-ExpectedPublisher '<publisher name in certificate>'
dist/win-unpacked/Pulse.exe checked by the current CI during cross-assembly; this path must be confirmed during the first native launch pack:win. The team uses standard Windows PowerShell 5.1. The script fails if the signature is empty or incorrect, the publisher is different, and the installer and application have different certificates; prints SHA-256 and certificate thumbprint. Even Valid does not prove the absence of a SmartScreen warning: it is checked separately on clean Windows with a file of this particular release. Currently, GitLab CI does not have signature variables and a connected Windows runner; There is no native run, so the issue remains unsigned. Microsoft describes, why OV and EV require reputation accumulation.
CLI agents (Claude Code, Codex) come in separate packages for a specific platform, and npm installs only the version for the current machine. When building a different architecture, you need to explicitly check that the package contains binaries of the target platform.
ARM64 for Windows and Linux is not yet being built for the same reason: a runner on ARM is needed. In addition, node-pty does not have ready-made builds for Linux - it is compiled during installation.
What works everywhere
Tasks and worktree, agent sessions via ACP, built-in agent over local models and GigaChat, graph, diff and commit, swarm, policies and budgets, quality, memory, notes, activity, cloud and updates. The task terminal works on all three systems: on macOS it is zsh, on Ubuntu bash, on Windows PowerShell.
Where does git come from?
Tasks, worktree, diff, commit, swarm - Pulse does all this by launching a real git. Your git in default builds no: on macOS it is provided by Xcode CLT, on Ubuntu - by the package manager. On Windows it’s a different history: there git is not installed by default in any package, and it is installed manually from the page https://git-scm.com/download/win.
Previously, the absence of git meant silence: the command fell somewhere inside Node, and the person saw
spawn git ENOENT. Now any operation with a repository on a machine without git says directly what is missing, what does not work because of this and what to put - with the address for Windows, the command
xcode-select --install for macOS and apt install git for Linux.
If git is installed but not in PATH (portable installation, non-standard prefix), the full path to it is set by an environment variable PULSE_GIT_PATH - it interrupts both the packaged git and the system one. The application receives the environment at startup, so after editing it needs to be started again; how to do this on each system - in If something went wrong.
The assembly can be assembled and with your git inside: catalog build/git in the repository tree goes to resources/git and is preferred to the system one. They put the transferred git there by hand before building; the directory is empty - the assembly behaves as before. Downloading is intentionally not built into any build script: automatically downloading someone else's binary into a release turns hacking someone else's server into hacking Pulse. Where to get portable git for Windows and Linux, how to verify the checksum and verify the signature, and in what layout to unpack - in build/git/README.md.
What is packaged by git not covers: terminal tasks and agents. When you type git
in the Pulse terminal or the agent CLI does it, the shell searches for the command - in the system PATH, not in the assembly. Packaged git runs where git itself runs Pulse: tasks, worktree, diff, commit, swarm, parcels.
Which is only on macOS for now
| Feature | Why |
|---|---|
| Monitoring sessions outside of Pulse | The hook for Claude Code is written in a shell script. It is not installed on Windows. |
| Application signature | Of the desktop builds, only macOS is signed with its certificate. Windows installer is not signed: SmartScreen may show a warning, you need to click “More details” → “Run anyway”. To sign, you need an Authenticode certificate (the previous budget guideline was from 15 thousand rubles per year; the supplier’s offer was not received). OV/EV type not selected yet: Microsoft reportsthat EV no longer grants instant SmartScreen reputation. The Android package is signed with its own key - see. "Android Package Signing" below. |
| Cleaning up images after updating | Retrieves mounted DMGs - this is a macOS concept. On other systems, Pulse simply deletes downloaded files that are not newer than the current version. |
Team sandbox
Mandatory Agent Boundary (#467, testing ongoing)
External ACP, bash The embedded model and agent PTY require a system read barrier regardless of the old Sandbox setting. The main process canonizes the working folder, executable file and profile of the selected CLI, creates a private TMPDIR, then runs a synthetic probe: a file outside, a link to it inside, and the child shell should fail. If the mechanism is missing or the test fails, the agent command does not run. Old agent PTYs are closed when restored after a restart.
On macOS profile sandbox-exec prohibits file-read* by default and allows working folder, private temp, system startup paths (/System/Library, system Cryptexes,
/usr/bin, /usr/lib, /usr/libexec, /usr/sbin, /usr/share, /bin, /sbin, /dev,
/etc, /private/etc, /private/var/select), Apple toolchains (/Library/Developer/CommandLineTools,
/Library/Frameworks, /Library/Apple), at Homebrew (/opt/homebrew, /usr/local) - program directories only (bin, sbin, lib, libexec, opt, Cellar, Caskroom, share, include,
Frameworks) and from etc what node, curl, python and git read (openssl@3, ca-certificates,
gitconfig); owner's decision 10/07/2026, #663; toolchain-applications - Xcode.app/Contents/Developer
(and directory from xcode-select -pif this is real Xcode or /Library/Developer), /Library/Java/JavaVirtualMachines,
Docker.app/Contents/Resources/{bin,cli-plugins} (#665). var and the rest etc prefix (data and service configs: npmrc, wireguard, DB), Library/Taps, house, /Library and /opt entirely - closed; catalogs from PATH are not resolved by themselves. The main process resolves the actual file of the selected CLI and its specific symlink; for Homebrew Kimi, the files of Node and its libraries are separately defined. Live macOS canary in user directory PATH gets rejected even if, after building the profile, the allowed symlink is replaced with this file. Codex, Claude and Kimi pass --version under profile with synthetic HOME. Programs from home directories PATH (~/.nvm, ~/.local/bin, ~/.cargo/bin) under the border still do not start: the house is closed, but open bin-the entire catalog is not possible; for them there is a separate checked list of runtime files, like for Homebrew Kimi. For ACP, the executable command file, built-in adapter dependencies, and the selected CLI authorization profile are added (.pulse-claude-agent, .codex, .kimi/.kimi-code or OpenCode profile). Writing is allowed to the working folder, private temp and profile of this CLI. This obvious exceptions: A secret placed in one of them will be available to the agent. Checking on macOS confirmed a failure for a file in the neighboring HOME directory, a link, a child shell, someone else's temp, and an attempt to read the environment of a neighboring process via ps eww.
Claude inside Pulse only runs with a separate OAuth token from claude setup-token
(priority and validity of the token in the Anthropic documentation): a person creates it in the system terminal and saves it in Settings → Agents. The main process holds the token in Secrets and transmits through the environment only Claude ACP and its background claude -p. Without a token, these calls will not run. CLAUDE_CONFIG_DIR indicates private ~/.pulse-claude-agent; general ~/.claude and
~/Library/Keychains/login.keychain-db are no longer allowed. General Claude skills, settings and hooks do not appear automatically in this individual profile. The synthetic token gives authMethod=oauth_token for claude auth status, but even a obviously invalid CLI token is marked as loggedIn=true: only a request to the server will show actual validity. macOS test checked the failure to read the neighboring synthetic Keychain and successful initialize/session/new ACP with a synthetic token. Claude also reads metadata /tmp, /private/tmp and /private/tmp/claude-<uid>; only the directories themselves are allowed for them (literal), the contents of adjacent files are closed.
Homebrew Kimi requires its package directory, Homebrew Node and its dynamic libraries. Pulse reads shebang of installed Kimi, gets Node dependencies via system
otool and resolves specific files along with intermediate symlinks; all Cellar does not open. For Node with OpenSSL 3, the exact file is allowed openssl.cnf. Check
kimi --version under a real profile and failure to read an adjacent file are included in the macOS test. Non-standard Homebrew shebang or library outside Cellar stops the launch instead of expanding access at random. Codex global npm installation reads its directory @openai/codex, where the native optional package is located; without this file codex.js runs, but does not find the binary. OpenCode, when first launched, creates ~/.local. The main process prepares only its four profile/cache directories in advance (.config/opencode, .local/share/opencode,
.local/state/opencode, .cache/opencode) and checks the real HOME, symlink, owner and permissions of each part of the path. Herself .local the agent is not entirely permitted. In a synthetic HOME with an empty OpenCode profile, after preparation we went through codex --version and
opencode --version; real OpenCode/Codex authorization was not run in this test.
On Linux profile bwrap is built with an empty root, separate /proc and bind only for system startup paths, working folder, private temp and CLI profile. Symlink of the selected CLI to a file outside the system directories is created inside the sandbox with the target to an already resolved canonical file; the adjacent directory is not mounted entirely. Mandatory behavioral checks are included in the GitLab task for a separate runner linux-userns; Linux is not accepted until it is successfully run. If the container does not allow user namespaces, the step fails and the agent remains stopped. There is no local Docker daemon on the development machine.
On Windows there is no effective boundary: external ACP and agent commands stop. The human terminal operates separately. process.env the external ACP is no longer transmitted in its entirety; it only receives startup/locale variables and keys that the registry has explicitly issued to that agent.
Client fs/readTextFile and fs/writeTextFile ACPs are executed by the main process, so one check realpath before asking for permission was vulnerable to replacing a file or parent directory with a symlink while waiting for a response. On macOS, after allowing Pulse, it opens the entire path with the system O_NOFOLLOW_ANY and reads or writes only through the held handle; the write will not truncate the file until the handle is checked. Flag support is tested on synthetic symlinks. On Linux and Windows, this client capability is not advertised, and the direct call is refused until an equivalent safe opening occurs; the tools of the agent itself are subject to a separate system boundary above.
Built-in Local Model and GigaChat agents have file tools
read_file, write_file, edit_file, list_dir, search, code_map and code_search
were executed by the main Pulse process: path checking and subsequent reading were separated, so replacing the intermediate directory with symlink could take the reading outside the worktree. ui_template also reads the file by the main process: with the library in the managed folder, the symlink of the template revealed the synthetic secret from the outside. While there is no atomic discovery for these tools on every platform, at a mandatory boundary they are not offered to the model, and an unexpected call is rejected. The background code map is not built. The built-in agent can work with files via bash
under the system sandbox; static block list ui_catalog remains available, but ui_template reads HTML from disk and is therefore closed. External stdio MCP servers for these two agents also do not start, because their process does not yet inherit the system read boundary. The session reports this once. In mode without
readBoundary the old tools and MCP continue to work as before.
The macOS profile also prohibits the agent from outgoing Unix sockets with the path: before the fix, the synthetic secret was read through the socket outside the task even when network: false. After the fix, the behavioral test failed for a socket in a neighboring folder, for a symlink inside a task, and for sockets in the task itself and the allowed CLI profile - in both positions of the network switch. This is important: a process outside the sandbox can serve a socket in an allowed folder. When the network is allowed, only the resolver's system socket remains in the exception list; request localhost passed through the system resolver. The synthetic Keychain, named after a path outside the task, was not read either before or after the fix. Real PTY, Homebrew Kimi version and initialize/session/new Claude ACPs with an invalid test token continue to work.
This is a boundary for reading files and Unix sockets with a path, rather than completely isolating user secrets. macOS profile saves (allow default) for other classes of operations: Mach/XPC and other local IPC are not tested. TCP on localhost remains available when the network is enabled; a local service may return data that is not directly accessible as a file. The token is intentionally visible to the Claude process itself and its child tools; it is not transmitted to other agents through the environment. The full prompt cycle with a real token has not been verified. The task remains open until a behavioral run of Linux and checking the remaining channels.
Voluntary human terminal sandbox
The person tab still has a write limitation switch: it writes to the working folder, temporary folder and caches; reading is not limited to this old regime. The network access is closed separately. It uses the system mechanisms from the table below.
| System | Than | What holds |
|---|---|---|
| macOS | sandbox-exec with SBPL profile |
recording outside the permitted places is refused; network ban closes outgoing and name resolver, leaving loopback and unix sockets |
| Linux | bubblewrap (bwrap) |
the system root is mounted read-only, writable worktree is returned on top, /tmp, /var/tmp and caches; network ban - your own network namespace |
| Windows | nothing | nothing: commands are executed without write restrictions and with an open network |
The “what holds” column describes the behavior when the sandbox is enabled; the network ban reaches the mechanism from 0.30.27 - analysis below, in “What we don’t know about this.”
Linux: why `bubblewrap` and why with experience
bwrap - the most direct way to limit recording that a conventional system provides, without requiring either administrator rights or third-party code. It is not available everywhere (package bubblewrap, follows Flatpak) and does not work everywhere: the kernel needs user namespaces, but they are turned off - kernel.unprivileged_userns_clone=0 in Debian, AppArmor profile in fresh Ubuntu, stripped-down seccomp in the container. Then bwrap prints “Creating new namespace failed” and does not launch anything at all.
Therefore, Pulse does not trust the presence of the file. Before the first command, he gives an experiment: he tries to write a file outside the working folder - first without a sandbox, then under it. The sandbox is turned on only if the entry passed without it, but under it was rejected. Any other outcome - the commands go as is, without restrictions, and the reason is written to the application log (userData/logs/pulse.log, lines "[sandbox]..."). Double experience is needed precisely because a one-sided “not allowed outside” would mistake the broken environment for protection.
Tested by behavior - the same code as in the application, on the Linux 6.x kernel from a regular user without administrator rights (the test took place in a container, the project does not yet have desktop Linux, see “What we don’t know” below): entry in worktree and /tmp passes, writing to the home folder is refused (“Read-only file system”), reading the system, /dev/null, git, npm init, npm install and the assembly work, if the network is disabled, the name is not resolved. Where namespaces are prohibited, the same code honestly falls back to "no sandbox".
One little thing with consequences: missing caches (~/.npm, ~/.cache, ~/.pip,
~/.cargo/registry) Pulse creates itself before the first launch under the sandbox. A folder that doesn't exist bwrap cannot make it writable, even on a fresh machine npm install would fall on
mkdir '~/.npm': read-only file system - that is, the sandbox would break exactly the work for which it is kept turned on.
How Linux differs from macOS: network denial is done by a separate network namespace, and loopback within it yours. The server that the team raised itself is available to it, and the service is on 127.0.0.1 outside the sandbox - no longer. On macOS loopback is common.
What was considered and rejected: seccomp filters system calls, but not paths - “write only to worktree” cannot be expressed with them; Landlock (kernel 5.13+) expresses exactly this, but lives in system calls, and Node has no access to them without a native module; systemd-run --user with
ProtectSystem=strict and ReadWritePaths= describes exactly what is needed, but relies on the same namespaces as bwrap, and the team is taken to a separate unit of the user manager - stopping a task that kills the process tree would stop bothering it; firejail — a third-party program with setuid-root and its own history of vulnerabilities.
Windows: why nothing
This is not an unfinished project and not “we haven’t gotten around to it yet.” Writing to files on Windows is limited by a limited access token (CreateRestrictedToken + CreateProcessAsUser) and AppContainer - both only exist as Win32 API calls, which Node does not have without a native module. Job Objects, which are easier to access, count memory, processes, time and can kill the process tree, but do not concern writing to files at all. runas /trustlevel:0x20000
removes administrator rights, but not access to user files - that is, the worktree and home folder remain writable. "Windows Sandbox" (.wsb) is a virtual machine of the Pro and Enterprise editions, without a working folder inside and without intercepting output.
Therefore, on Windows, the switches in “Policies” are not available and are signed directly: they protect policies and the “Ask” mode, nothing else. There won’t be a plug that would “almost protect”: a sandbox that doesn’t hold is worse than one that doesn’t exist—under it, a person allows the agent more.
What we don't know about it
- Nobody ran desktop Linux. The mechanism is tested with the same code as in the application, but in a container. How will he behave?
bwrapunder Ubuntu with its AppArmor profile or under Fedora with SELinux, known only from descriptions - not tested on a live machine. If the experiment fails there, Pulse will not enable the sandbox and will write the reason to the log; that's the only thing we stand behind. - The window does not show the outcome of the experiment. The “Sandbox” section in “Policies” describes how it works on this system, but does not say how the check ended for you - for this you need a channel from the main process to a window, which does not exist yet. The outcome is visible in the journal.
- Network ban is connected and working (from 0.30.27). The switch “Exit to the network from the sandbox” in “Policies” reaches the mechanism:
createApiSessioninsrc/main/ipc.tstransfers sessionssandbox: agentSandboxOptions(s)(both callsnew ApiAgentSession(...)), andApiAgentOptions.sandboxinsrc/main/agents/apiAgentSession.tsannouncedboolean | SandboxOptions. On macOS the ban is(deny network-outbound)in the profile: closes outgoing connections and the name resolver, leaving loopback and unix sockets; on Linux ---unshare-net, a separate network namespace. On Windows there is nothing to prohibit - there is no sandbox there, and the switch is signed for this reason. - A person's voluntary sandbox does not interfere with reading. It limits writing, not reading; the mandatory agent boundary is described above. When the network is open, the contents of the paths allowed to the agent can be sent outside.
About storing keys
Pulse encrypts API keys and tokens with a system keychain: Keychain on macOS, DPAPI on Windows, libsecret on Linux. On Linux there may be no link (server without GNOME Keyring or KWallet) - then Electron cannot encrypt, and Pulse honestly writes to the log that the keys are in the file with rights 0600. On Windows, POSIX rights do not apply: the file is protected by the rights of your account to the folder %APPDATA%\Pulse.
What to expect when you first start
The first step is to open the setup wizard: it will show the agent installation commands for your system (npm install -g … everywhere brew install kimi-code only on macOS) and open them in the system terminal - Terminal on macOS, PowerShell on Windows, the first emulator found on Ubuntu. If you don't have an emulator, Pulse will be honest about it and show you the command so you can run it yourself. Details - in Installation.
- Windows. SmartScreen will warn about an unknown publisher (the application is not signed). One-click installation: no questions asked, no administrator rights, in
%LOCALAPPDATA%\Programs\pulse, shortcuts on the desktop and in the Start menu, Pulse opens itself; another folder - key/D=. Agents installed via npm (kimi,opencode), are launched via wrappers.cmd— Pulse can do this. If the agent is "not found", check that its command works in PowerShell. - Ubuntu. AppImage: Make the file executable (
chmod +x) and run; on 22.04 and newer he needslibfuse2(libfuse2t64on 04/24), and on 04/24 - the AppArmor profile for the Chromium sandbox, see. installation. deb package:sudo apt install ./Pulse-<version>.deb- dependencies will tighten up. Pulse stores keys and tokens in the system keychain via libsecret; if it is not there (bare server without GNOME Keyring or KWallet), Electron will save them to a file with normal rights - this is acceptable for a production machine, not for a shared server. - macOS on Intel. The same as on Apple Silicon: the first launch is allowed in System Preferences (“Privacy and Security” → “Open Anyway”), then “Always Allow” when prompted for a keychain. The blocking has nothing to do with the processor - it's a matter of notarization, see. installation.md.
Updates
The update server distinguishes between systems: the application requests a file specifically for its system and architecture combination (darwin-arm64, darwin-x64, win32-x64, linux-x64). Pulse downloads the file and verifies the manifest signature and checksum; Then everything starts just by clicking on your “Install” button:
- macOS — Pulse replaces itself if both copies are signed by the same certificate: it checks the SHA-256 fingerprint of the final certificate, signature, bundle id and version. If there is an ad hoc signature, different certificates, or a failed replacement, the image opens and you drag Pulse to Programs. Replacement
.apphappens beforeapp.quit(). Ifbefore-quitwill cancel the exit due to running agents, the process will continue to work with the old code with the already replaced application on the disk: the button does not promise that the new version will be enabled only after exit. - Windows — the copy delivered for you is updated silently: Pulse closes, the installer installs the new windowless version and opens it. The "for all users" copy and ZIP receive the installer window. If exit is cancelled, the installer waits for Pulse to close.
- Linux - Pulse opens the package in a systematic way, you set it.
The package extension also depends on the system, and the list is closed: .dmg and .zip on macOS,
.exe and .msi on Windows .deb, .rpm and .AppImage on Linux. This is not a formality: the downloaded file is opened by the system, and on Windows the installer launches Pulse itself, and .sh,
.command or an arbitrary executable file would simply be launched. A package with a foreign extension or from a foreign host is rejected before downloading, not after.
There is no completely deferred installation on macOS yet: replacement occurs before release, as stated above. The verifiable next step is to prepare a signed copy without touching the installed one, and replace it only after an accepted exit; undoing should leave the installed copy untouched.
Why not electron-updater. On macOS, autocorrect without a Developer ID is unreliable, and Pulse builds do not yet have a certificate (build.mac.identity = null), Windows does not have Authenticode, so there is nothing to confirm the publisher of the downloaded file - we only know that it came from the update server and matched the signed manifest and checksum. Putting it in such a position without the person’s knowledge is worse than pressing his button; Pulse does not install - only by “Install”. The argument “on Windows, an unsigned installer runs into SmartScreen”, which was stated here earlier, was incorrect: the file downloaded by Pulse itself does not have the “Mark of the Web” mark, and SmartScreen does not check it.
The feed itself is also not connected yet. The cloud sends JSON via /releases/latest?platform=…, not latest*.yml; the macOS build only releases a DMG, no ZIP for Squirrel.Mac. One certificate will not enable the feed: you need artifacts and metadata, checking their trust and maintaining verification of the signed manifest. Live check - two signed releases, old version to new, including canceling releases with working agents, spctl on macOS and Authenticode on Windows. Once the certificate appears, the meaning will also appear. electron-updater
with feed {cloudUrl}/releases/latest-{channel}.yml; the update server is already ready for this. Border next to button − installLimits().
Android and iOS
You cannot build Pulse for Android. Electron doesn't have an Android target and there's no way around it. But the main thing is not even this: Pulse works by launching processes on your machine - agents, git, terminal. They are not on the phone.
The smart way is remote control: The phone shows you what's going on and allows you to intervene, while the computer still does the work. Step by step:
- Gateway to Pulse (about ten days). Local HTTP service with a token - Pulse already has one for external sessions (
src/main/agents/externalStatus.ts), he takes it as a model. Pairing by QR code, exchange only within your network. - Mobile web client (about ten days). A separate lightweight interface for five to seven screens on top of common types: task list, live chat, button to respond to a permission request, submit the next step. Placed “on the home screen” without a store.
- App in store (about a week, as needed). The same web part wrapped in Capacitor for notifications on the locked screen. To do this, you need a constantly available repeater in the Pulse cloud - without it, the notification will not reach your phone.
A full-fledged native client on Kotlin (one and a half months) does not pay for itself now: the Pulse data model still changes from version to version, and it would have to be kept in two places.
Assembling the remote control for iOS
B ios/ lies the Capacitor project with Swift Package Manager. Requires macOS, Node.js 24+ and Xcode 26+ with iOS Simulator installed. After npm ci execute
npm run ios:sync: The team will build the same remote used in Android and update the web files and iOS plugins. Then open the project via npx cap open ios, select iPhone Simulator and launch the app in Xcode. In the project settings it is specified ru.avacloude.pulse.remote; When installing on a physical phone, configure the signing command and provisioning profile of your Apple Developer Account.
Built-in QR scanner announces the camera's purpose in Info.plist. Check
npm run ios:sync in GitLab CI only confirms the web part generation and project synchronization; it does not compile Swift and does not check for startup, camera access, or pairing. Before release, it requires assembly in the simulator, pairing with Pulse via QR on a physical iPhone, and verification of the signed package. While they are not there, the link on the site correctly leads to the web remote for iPhone.
Android package signature
The Capacitor wrapper lies in android/, the version and build number are taken from the root
package.json. Teams:
| Team | What collects |
|---|---|
npm run android:apk |
debug APK - put it on your phone and see |
npm run android:apk:release |
release APK - what is distributed as a link |
npm run android:bundle |
AAB is a format that Google Play accepts |
There is no signature key in the repository and there cannot be one. No storage file, no passwords, no key name. An Android application has one signature for life: a leaked key cannot be revoked, and changing the signature means asking everyone who has already installed the application to delete it and install it again. Therefore, the assembly takes properties from the environment, and if it does not exist, from Gradle properties that live outside the repository (usually ~/.gradle/gradle.properties):
| Environment variable | Gradle property | What is this |
|---|---|---|
PULSE_ANDROID_KEYSTORE |
pulse.android.keystore |
path to the keystore; relative is calculated from android/ |
PULSE_ANDROID_KEYSTORE_PASSWORD |
pulse.android.keystorePassword |
vault password |
PULSE_ANDROID_KEY_ALIAS |
pulse.android.keyAlias |
name of the key inside the repository |
PULSE_ANDROID_KEY_PASSWORD |
pulse.android.keyPassword |
key password; not specified - the storage password is taken |
Something is missing - the release is about to happen unsigned, but does not fall. To fall would be a lie about the reason: the key is needed only for the release, and the debug build and checking whether it’s going to work at all can be done without it, including on someone else’s machine and in someone else’s fork. Gradle prints a warning and names the missing information, and the file gets a name
app-release-unsigned.apk — it cannot be confused with a release.
How to get your own key
The key is created by the one who collects the release; there is no public key in the repository. The file is put
outside the repository - for example in ~/.pulse/:
keytool -genkeypair -v \
-keystore ~/.pulse/pulse-release.jks \
-alias pulse -keyalg RSA -keysize 4096 -validity 10000
Properties are conveniently put in ~/.gradle/gradle.properties: It's outside the repository, and you don't have to keep variables in each shell's environment.
pulse.android.keystore=/Users/name/.pulse/pulse-release.jks
pulse.android.keystorePassword=…
pulse.android.keyAlias=pulse
The key is unrecoverable. The loss means that you can never update an already installed application - you can only release another application under a different identifier, and everyone installs it from scratch. The copy should be in the same place as the rest of your secrets, not next to the code.
.gitignore at the root and in android/ are closing *.jks, *.keystore and files with signature properties, but this is the last protection, not a place for the key.
Build on GitHub Actions
Workflow Android package (.github/workflows/android.yml) collects APK and AAB on
ubuntu-latest: the assembly runs on the JVM, and it does not need a second runner for another system - so it stands separately from the matrix of desktop installers. Launch: Actions tab → “Android package” → Run workflow, or tag push vX.Y.Z.
Repository secrets (Settings → Secrets and variables → Actions):
| Secret | What do they put |
|---|---|
ANDROID_KEYSTORE_BASE64 |
the storage file itself in base64: base64 -i ~/.pulse/pulse-release.jks (on Linux base64 -w0 …) |
ANDROID_KEYSTORE_PASSWORD |
vault password |
ANDROID_KEY_ALIAS |
key name |
ANDROID_KEY_PASSWORD |
key password, if different from the storage password |
The task puts the key into a temporary runner file, collects it, verifies the signature via
apksigner and deletes the file in any case. There are no secrets - an unsigned package will be assembled: it will go to the launch artifacts under the name with -unsigned and will not be included in the release. It is impossible to install an unsigned package on top of a signed one, and the one who installed it would be left without updates forever.
How the package gets to the installation page
The path of the package is the same as that of desktop installers, and at no stage is the file address included in the site markup - otherwise the link would rot silently or lead to a closed release repository.
- Tag
vX.Y.Zruns "Android Package": build, signature verificationapksigner, packages are included with the release. In this case, no run artifact is created at all:upload-artifactstands under the condition “there was no signature OR there was no tag,” and on a regular release both terms are false. Sogh run download, which is downloaded by desktop installers, will not give the package - it is only in the release files. The artifact occurs in an unsigned assembly and in a manual launch without a tag, that is, when there is nothing to upload. cloud/publish-release.sh X.Y.Z <directory>postsPulse-X.Y.Z.apkto the update server under the platformandroid. The package is searched first in the directory and, if not found, in the release filesvX.Y.Zthroughgh release download; You don’t need to download it separately, but you need a working and authorized onegh. The name mask is accurate: lying nearby unsignedPulse-X.Y.Z-unsigned.apkwill not be picked up. If the release has responded and the package is not in it (an unsigned assembly has been built), the script says this in words and does not disrupt the release. If you weren’t able to look at the issue, nogh, no authorization, no network - the script calls ignorance ignorance and returns a non-zero code: previously this place was occupied by the word “pass”, the same for “no packet” and “we didn’t look”.- Card "Android package" on the installation page it asks
/releases/latest?platform=androidand takes the address, version and size from there - exactly like desktop cards. The package is not yet on the server - the card says so (“the package has not yet been uploaded”) and does not show a link to the file; the button leads to the web console, that is, it does not remain empty.
Rollout order: cloud → package → website. The card from point 3 is already in the collected
site/download.html, and the platform android only accepts new cloud. Uploading the package to the old cloud will not work (400 invalid_platform), and rolling out the site before the cloud means getting 400 for each card request and the message “the package is not being released yet” when the package is live. Full recipe - in Development.
android here is a distribution platform, not an update: the package does not have auto-updates, the Android application server does not ask for updates at all, the new version is installed by replacing the file. This does not apply to desktop update checking - the selection is filtered by platform, and the application takes the key from src/shared/platform.ts, where android it can't work out.
There is no store. The package is not posted on Google Play, and nowhere - neither on the website nor in the application - is a store promised: the installation page directly says that the package is installed and updated by replacing the file. AAB collects the task in reserve; no one sent it to the store.
Detailed plan based on code - in Mobile remote control. What was supposed to be completed in the cloud has already been done: there is a registry of machines (migration 0006_machines, routes /machines — each device is linked to an account, the second installId does not overwrite the first one; see Synchronization of settings), the event cursor, transcript pages and device accounting are also in place. The open steps are package distribution and publication in stores (see above). Adjacent - in group work plan.