* ci: cross-build the daemon for each release target
* ci: use Android anet linker compatibility flag
* ci: skip BSD VMs for build-only targets
* ci: FreeBSD and OpenBSD on ARM64 run the workloads in ARM64 VMs, not only build
* docs: the BSDs on ARM64 run the workloads too, and every target's daemon is built in CI
* ci: use tar sync for FreeBSD arm64 VM
---------
Co-authored-by: Austin L. <86896075+rvnminers-A-and-N@users.noreply.github.com>
* ci: test and rehearsal back on GitHub's runners
The self-hosted runner ran one job at a time behind a lock, so every
pull request queued for it. GitHub's runners are free for a public
repository and give each job a machine of its own.
* ci: a pull request's newer push cancels its older run
* ci: one blank line before the concurrency block
* ci: a pull request that changes only documentation runs no builds
* ci: pull requests package the three main platforms; dev and all-platforms pull requests package all six
* ci: the workloads checked on every other system a release is built for
RISC-V, 32-bit ARM, POWER, IBM Z and LoongArch under an emulator, 32-bit
x86 and Android natively, and FreeBSD, OpenBSD and NetBSD in virtual
machines. Releases gain Linux on 386, ppc64le, s390x and loong64, and
OpenBSD on arm64.
* ci: qemu-user on Ubuntu 26.04, and the Android build loaded by Linux's loader
* ci: every system on x64 and arm64, on the newest runner images
The desktop app is packaged, and the known-answer workloads checked, on
Ubuntu 26.04, Windows 2025 and Windows 11, and macOS 26, each on x64 and
on arm64. Jobs name their image rather than -latest, download-artifact
moves to v8, and Dependabot keeps actions, Go modules and the desktop's
packages current.
* fix: verify unpacked packages on arm64
---------
Co-authored-by: excho0 <realexcho@gmail.com>
* ci: run trusted Linux checks on self-hosted runners
* ci: reuse self-hosted Go caches without upload
* ci: use preinstalled Node on self-hosted runners
* test(desktop): isolate CI Electron in Xvfb
* ci: enter the development shell for coverage
* fix(desktop): a window with no WebGL shows the workspace without its globe, not nothing
* test(desktop): end-to-end tests of the real app against a node of their own
* fix(desktop): a window with no WebGL is not offered the topology at all
* test(desktop): the WebGL test says why a topology is not there
It asks the window whether it has WebGL and how wide it is before it looks
for the topology's handle, and sets the window to its opening size. On a
machine that draws no WebGL even in software it is skipped with the reason,
except in CI, where that is a failure.
* feat(desktop): the logo on the app, and installers for Windows, macOS and Linux
* test(desktop): the packaging test expects the icon and the installers
* feat(release): publish the desktop packages, and say how to get past the first-run warnings
* feat(desktop): the logo on the app, and installers for Windows, macOS and Linux
* test(desktop): the packaging test expects the icon and the installers
* feat(desktop): own local daemon startup and shutdown
* feat(desktop): package native apps with matching daemon
* fix(desktop): prefer the CLI pool port and allow graceful daemon shutdown
* fix(packaging): stamp and verify the embedded daemon version
* feat: IPFS Cluster beside Kubo, with the store's pins as cluster pins
* feat: tests against a stand-in cluster peer, docs, and IPFS Cluster in CI
* feat: one --replicas for both ways of keeping copies
--replicas N is how many copies other nodes hold besides the
coordinator's own, whether storage followers keep them or, with
--cluster, the cluster's peers. --cluster-replicas, which counted the
coordinator, is gone. With --cluster the built-in scheme is off.
* fix: a cluster is not asked to pin the records of jobs
A record is linked data whose pin keeps it and not the blobs it names.
Pinned on a cluster it would have held those blobs on every holder for
as long as the job is remembered, past the time its data is kept for.
* chore(dev): align Nix and documentation with the Go daemon (#100)
* chore(desktop): upgrade dependencies and prepare streamed markdown (#85)
* feat(desktop): bridge daemon commands, streams and file transfer
* feat(desktop): add shared page states and localized feature labels
* feat(chat): add streamed planner, history and shared composer (#80)
* feat(models): configure providers and manage model downloads (#79)
* feat(operations): add jobs, files and pool management (#81, #82, #83)
* feat(node): show worker hardware and shared connection states (#84, #99)
* feat(workspace): integrate chat and persistent responsive panels (#98, #99)
* fix(desktop): clean up terminal and cancelled RPC streams
---------
Co-authored-by: Austin L. <86896075+rvnminers-A-and-N@users.noreply.github.com>
Go is the one implementation of the node, as decided on #90. The Go
daemon does everything the Rust one did, and carries a node's key,
address book and trusted peers over from it on first start. This removes
apps/sisyphusd-rs, the Cargo workspace and the rust job in CI.
A new workload, container, runs an image once for each task of a job,
with Docker. Each task is told which copy it is and how many there are.
A stored file can be given to every task, and what a task prints and the
files it leaves are stored and returned by CID. What it prints is also
its log, as it goes. Memory and processor limits are enforced, a task
has no network unless the job asks for it, and it runs as the node's own
user. Cancelling the job or timing out a task kills its container.
A worker runs containers only when started with --containers, because
that lets whoever may submit jobs run what they like on the machine. Any
coordinator takes such a job in; it waits for a worker that runs them.
The planner is now told only of workloads that some connected worker
runs, so that it asks for nothing the pool would leave waiting.
Closes#9. Part of #10.
sisyphusd run --api-listen 127.0.0.1:50051 serves sisyphus.node.v1, the
API the desktop app uses, in terms of pools: a node's peers are the nodes
admitted to its pool (or, on a worker, its coordinator), and trusting a
peer for compute admits it as a worker. Ending trust removes the member
exactly as pool remove does, re-keying included.
The API is loopback-only and has no TLS, as the app expects, so anything
on the machine can read it. Changes need the token the daemon keeps in
api.token in its data directory; the desktop app now sends it. The
address-book calls say that pools are joined by invitation. The country
is left empty rather than asking an outside service.
CI now also type-checks and builds the desktop app and runs the Rust
daemon's tests. packages/sealed joins the coverage gate, which it already
met.
With --kubo, a coordinator starts Kubo on a repository in its data
directory, running as the same peer as the node, offline and with no
route to the public network, and stores its blocks there through
Kubo's API. Anything the node stores is then an ordinary IPFS file,
and anything added with the ipfs command can be a job input.
The store's own pins and garbage collection work unchanged on top, and
a collection leaves alone whatever Kubo itself has pinned.
CI installs a pinned Kubo, and tests that need it fail rather than
skip when it is missing there.
Adds scripts/build-release.sh, which builds sisyphusd for Linux, macOS
and Windows with checksums, a workflow that runs it on v* tags and
publishes a GitHub release, and a version command. Pull requests that
touch the release machinery run the build without publishing.
Worker-only nodes now keep fetched blobs in a cache store.
Adds tests that drive the coordinator, worker, blob transfer and command
line through their failure paths: workers that send malformed or bogus
messages, nodes that drop mid-transfer, disks that fail, unusable
addresses. Code that only existed to handle failures gRPC reports
elsewhere is removed. `make cover` fails unless every statement of
hand-written code is executed, and CI runs it.
rvnminers-A-and-N
excho0andrvnminers-A-and-N