Docs
Docs menu

moru-node commands

Every moru-node command with its arguments and flags, grouped by what you use it for.

moru-node is the node: it serves the web UI, the API, git and the MCP server, and its other commands manage the data directory. In the container image, run them with docker compose exec moru moru-node … (or your platform’s shell); they run as the node’s user and find the data at /data.

moru-node [OPTIONS] <COMMAND>

moru-node --help and moru-node <command> --help print the same for the version you run. moru-node --version prints the version.

Global options#

Every command takes these.

FlagVariableDefault
--data <DATA>MORU_DATA./dataThe node’s data directory.
--identity <IDENTITY>MORU_IDENTITYthe data directory’s, or key for a new oneThe host identity: key (an offline did:key) or plc (a did:plc, registered by the first serve; needs --public-url). A value that differs from the data directory’s refuses to start. See Host identity.
--plc-url <PLC_URL>MORU_PLC_URLthe host’s, or https://plc.directoryThe PLC directory. Only serve (and host --refresh) contacts it: for the host’s own log, and, about every 12 hours, for the logs of the other did:plc hosts the node trusts as attesters or imported repos named. See How trust works.
--no-plc-refreshMORU_NO_PLC_REFRESHoffDon’t fetch other hosts’ logs from the PLC directory, for an air-gapped node. Logs fetched before then count for nothing: trust rests on the repos and what the node learned from them. Set it for every command on the data directory, not only serve.

Arguments called <REPO> are owner/name, for example acme/timetable. Durations are a number and a unit: 90s, 15m, 4h, 7d.

Run the node#

serve#

Runs the node until SIGTERM or SIGINT. On a node with no admin yet, it prints a setup link for the first one.

moru-node --data /var/lib/moru serve --listen 127.0.0.1:7070 --public-url https://moru.example.com

Every flag has an environment variable. Configuration explains each one.

FlagVariableDefault
--listen <LISTEN>MORU_LISTEN127.0.0.1:7070
--public-url <PUBLIC_URL>MORU_PUBLIC_URLhttp:// + the listen address
--trusted-proxy <TRUSTED_PROXIES>MORU_TRUSTED_PROXIESnone
--landingMORU_LANDINGoff
--events-retention <EVENTS_RETENTION>MORU_EVENTS_RETENTIONkeep every event
--job-queue-ttl <JOB_QUEUE_TTL>MORU_JOB_QUEUE_TTL12h
--scratch-ttl <SCRATCH_TTL>MORU_SCRATCH_TTL24h
--prune-expire-days <PRUNE_EXPIRE_DAYS>MORU_PRUNE_EXPIRE_DAYS14
--scratch-quota-mib <SCRATCH_QUOTA_MIB>MORU_SCRATCH_QUOTA_MIB50
--push-quota-mib <PUSH_QUOTA_MIB>MORU_PUSH_QUOTA_MIB2048
--agent-token-ttl <AGENT_TOKEN_TTL>MORU_AGENT_TOKEN_TTL4h
--github-url <GITHUB_URL>MORU_GITHUB_URLhttps://github.com
--github-api-url <GITHUB_API_URL>MORU_GITHUB_API_URLhttps://api.github.com
--github-public-url <GITHUB_PUBLIC_URL>MORU_GITHUB_PUBLIC_URLthe public URL
--ui-origin <UI_ORIGINS>MORU_UI_ORIGINnone
--webhooks-allow-privateMORU_WEBHOOKS_ALLOW_PRIVATEoff
--scripted-profilesMORU_SCRIPTED_PROFILESoff
--runner-downloads <RUNNER_DOWNLOADS>MORU_RUNNER_DOWNLOADSnone (the image sets it)

A host with many nodes adds these. Running many nodes explains how they fit together.

FlagVariableDefault
--role <ROLE>MORU_ROLEallall: repos and the host-wide state. control: only the host-wide state. repo: only repos, for the control node it joined. control and repo need --internal-listen.
--internal-listen <INTERNAL_LISTEN>MORU_INTERNAL_LISTENnone (standalone)The internal API’s listener, for the host’s other nodes, for example [::]:7071. Keep it on a private network. With it, a node with role all is the host’s control node.
--internal-url <INTERNAL_URL>MORU_INTERNAL_URLnoneThe URL the host’s other nodes reach this node’s internal listener at. Required with --internal-listen.
--control-grace <CONTROL_GRACE>MORU_CONTROL_GRACE5mHow long a repo node keeps accepting people’s and runners’ tokens after it lost contact with the control node.
--request-rate <REQUEST_RATE>MORU_REQUEST_RATE10How many requests one account may file in an hour on repositories it can’t write to (they wait in triage); 0 for no limit.
--replay <REPLAY>MORU_REPLAYnone (forward every request)fly: answer small requests for another node with Fly.io’s fly-replay instead of forwarding them. Needs FLY_APP_NAME and FLY_MACHINE_ID, which Fly sets.
--control <CONTROL_URL>MORU_CONTROL_URLnoneFor a repo node’s first start: the control node’s internal URL, to join with an enrollment token. A node with another role ignores the variable.
--join-token-file <FILE>MORU_JOIN_TOKENnoneThe enrollment token for --control: a file holding it, or the token itself in the variable. Never on the command line. A node with another role ignores the variable.
--max-restore-upload <SIZE>MORU_MAX_RESTORE_UPLOAD20GThe largest backup a site admin may upload from the web app to restore a revoked or retired node’s repositories on this node. Bytes, or with K, M, G or T (powers of 1024).

host#

Shows the host identity: its DID, its kind (key or plc) and the node’s DID, and for a did:plc host its current signing key and log head.

Flag
--refreshFetch a did:plc host’s log from the PLC directory first, as serve does. Without it, the cached log is checked offline.
moru-node host

checkpoint#

Records which objects in each repository this node’s key signed, in checkpoints/ in the data directory, and prints where. If nothing changed since the newest checkpoint, it says so and writes nothing. serve takes one when it starts and every 10 minutes, and keeps the last 144 that differ. Copy them somewhere off the node: revoke-node needs one from before a leak.

moru-node checkpoint

retire-node#

Retires another node’s key, for a node that left cleanly. In every repository it revokes the key from now (plus five minutes for clock differences), vouching for everything the key signed there: those changes keep verifying, and the key can’t sign anything new. Run it only once that node has stopped writing and its changes have reached this node. It refuses this node’s own key, and a key no repository’s host object certifies.

Before it writes any repository, it records the revocation in host/revocations.json, with a checkpoint of what it vouches for in each repository (in host/checkpoints/), and prints “recorded in host/revocations.json”. From then on the node refuses the key from that time in every repository, including a copy that lacks the revocation (an import, a restored backup), and writes the revocation into such a copy, vouching for what the checkpoint lists there. See How trust works.

If a repository fails, run it again: the rerun revokes from the time the first run recorded, leaves the repositories that already hold the revocation as they are, and maps what the key signed in the ones it failed in at the time of the rerun. Run after revoke-node for the same key, it keeps that command’s time and checkpoint, and says so.

moru-node retire-node did:key:z6Mk…

On the control node of a host with many nodes it does something else: the host stops trusting that node, so its tokens and requests are refused everywhere from then on. It writes nothing into repositories. It refuses a node that still holds repositories (move them first: all at once with drain-node, or one at a time with move-repo or the repository’s settings), has some in its trash or is creating one, and a node that hasn’t reported since the control node’s index was rebuilt. It runs beside serve; the running node picks the change up. Retire… in Settings → Network does the same.

revoke-node#

Revokes a leaked node key from a point in time, vouching only for what a checkpoint taken before then lists. Changes the key signed that the checkpoint doesn’t list stop verifying. Use a copy of the checkpoint kept off the leaked node, such as one from a backup: a file read from that node’s disk proves nothing.

Flag
--at-ms <ms>When the key stops counting, in milliseconds since the epoch.
--vouched-from <file>A checkpoint of that key, taken before --at-ms. Optional in a copy of a control node’s data directory, which keeps the checkpoints its nodes reported: then the newest one before --at-ms. Refused on the control node of a host with many nodes.
--no-waitOn the control node of a host with many nodes: start the revocation and return without following it.
moru-node revoke-node did:key:z6Mk… --at-ms 1762905600000 --vouched-from backups/old-node/checkpoints/1762900000000.json

Like retire-node, it records the revocation and keeps the checkpoint in host/ before it writes any repository. If a repository fails, run it again. A rerun goes by the record:

  • the same --at-ms writes what’s missing, and adds what the checkpoint given lists that the kept one doesn’t (where both name an object at different versions, the kept one stays);
  • a later --at-ms writes from the recorded time instead, and says so; the checkpoint given isn’t used;
  • an earlier --at-ms replaces the record with the new time and checkpoint, which widens the revocation.

If host/revocations.json can’t be read, both commands refuse and say what to do: see How trust works.

On the control node of a host with many nodes, it does the whole revocation for the host:

  • the host stops trusting the node at once, whatever it holds, and its tokens and requests are refused everywhere;
  • moves to and from the node are rolled back (one whose target already had the repository in place goes forward);
  • every node writes the host’s signed revocation into each of its repositories the node’s key signed in, vouching for what the newest checkpoint of it that the control node had received by --at-ms lists. With no such checkpoint (the control node keeps them 30 days), it vouches for nothing.
  • the control node records the revocation in host/revocations.json with a copy of that checkpoint, never pruned, and sends the record to every node, which goes by it even while the control node is down. If the record can’t be written, the command fails after the host stopped trusting the node and before any repository is written: fix what it names and run it again.

It runs beside serve and hands the writing to the running node. It follows it and prints, per node, what it wrote in each repository, then the repositories the node held, which stay unavailable until they’re restored on another node with restore-repos. If a node didn’t answer or a write failed, run it again. A time more than a minute in the future is refused; a node revoked already takes an earlier time, which widens its revocation. Revoke… in Settings → Network does the same. Pick the time no later than the suspected compromise: see Revoke a node.

Many nodes#

These run on the control node of a host with many nodes, except join, which runs on a new node, and restore-repos, which runs on the node that takes the repositories. Commands that change something run beside serve and hand the work to the running node. See Running many nodes.

node-code#

Makes a one-time node code that lets one new node join this host within an hour, and prints it once. On a node that doesn’t serve with --internal-listen yet, it notes that nothing takes joins until it does.

moru-node node-code

node-token#

Makes an enrollment token, which lets nodes join by themselves on their first serve (with MORU_CONTROL_URL and MORU_JOIN_TOKEN), and prints it once. Keep it secret: until it expires, is used up or is revoked, it adds nodes to the host.

Flag
--ttl <TTL>How long the token works. Default 30d.
--max-joins <MAX_JOINS>How many nodes may join with it. Default 5.
--listList the tokens: ID, state, created, expires, and the nodes that joined.
--revoke <ID>Revoke the token with this ID, as --list shows it.
moru-node node-token --ttl 7d --max-joins 2
moru-node node-token --list
moru-node node-token --revoke 3f9a1c0e

nodes#

Lists the host’s nodes: key ID, DID, role, internal URL, version, state (active, retired or revoked) and last report. On a repo node it lists that node’s copy from the control node.

moru-node nodes

join#

Joins a host as a repo node: makes this node’s key, has the control node certify it with a node code or an enrollment token, and writes the host into the data directory. Then serve it with --role repo and the same --internal-url. Only an empty data directory joins: one with accounts, repositories, runners, organizations or a host already is refused. To grow a host from an existing node, serve that node with --internal-listen instead.

Flag
--control <CONTROL_URL>Required. The control node’s internal URL.
--internal-url <URL>Required. The URL the host’s other nodes reach this node’s internal listener at.
--code-file <FILE>A file holding the node code or enrollment token. Or set MORU_JOIN_CODE. Never on the command line.
moru-node --data /var/lib/moru join --control http://10.0.0.2:7071 --internal-url http://10.0.0.3:7071 --code-file node-code.txt

A data directory restored from a repo node’s backup joins too: it joins as a new node, takes over the old node’s repositories, and the old node is retired. See restore.

move-repo#

Moves a repository to another node of the host. Its writes pause while it moves (503 with Retry-After: 30); reads keep working. Queued jobs are cancelled; running ones may finish within the drain time, then are cancelled. The command follows the move and prints each step.

moru-node move-repo [OPTIONS] <REPO>
Flag
--to <NODE>The target node: its DID or key ID, as nodes lists them. Required unless --abort.
--drain <DUR>How long the repository’s running jobs may go on before they’re cancelled. Default 10m, at most 24h.
--no-waitHand the move (or the abort) to the running node and return. Follow it with moves.
--abortAbort the repository’s move: before the switch it’s rolled back; at the switch only while the target hasn’t put the repository in place.
moru-node move-repo acme/timetable --to 2
moru-node move-repo acme/timetable --to 2 --drain 30m
moru-node move-repo acme/timetable --abort

It refuses an organization’s .moru repository, a repository linked to GitHub, one in the trash, a target that isn’t active or holds no repositories (role control), and a host where a node runs a release from before 2026.11.7. The target checks it has free disk space of twice the repository’s archive plus 64 MiB before it copies. A move that fails (its jobs didn’t drain in time, its copy kept failing, its target lacked the free space) leaves the repository paused on its node: run the same command again to go on, or abort it. See Move a repository.

drain-node#

Moves every repository it can off a node of the host, one at a time, each to the active node that takes repositories and holds the fewest. From the moment it starts, the node takes no new repositories, and that lasts after the drain finishes, until --undo. An organization’s .moru repository and a repository linked to GitHub stay on the control node, a repository in the trash stays, and so does one left paused by an earlier move that failed. A move that fails before its switch is rolled back and the drain goes on with the next repository; a target without the free space gets one more try on another node. Five failed moves in a row stop the drain. The running node does the drain and picks it up again after a restart; the command hands it over and follows it.

moru-node drain-node [OPTIONS] <NODE>

<NODE> is the node’s DID or key ID, as nodes lists them.

Flag
--to <NODE>[,<NODE>…]Only move to these nodes (DIDs or key IDs). Default: any active node that takes repositories.
--drain <DUR>How long each repository’s running jobs may go on before they’re cancelled. Default 10m, at most 24h.
--no-waitHand the drain (or the abort) to the running node and return. Follow it with moves.
--abortAbort the node’s drain: no more moves start, and the move in flight is rolled back if it hasn’t switched over. The node still takes no new repositories.
--undoLet the node take new repositories again. Refused while a drain of it is running.
moru-node drain-node 1
moru-node drain-node 1 --to 2,3 --drain 30m
moru-node drain-node 1 --abort
moru-node drain-node 1 --undo

It prints the drain’s ID, then a line for each step as it happens:

drain 1762992000000-3f9a0c1d2e4b submitted: it moves every repo off node 1 (did:key:z6Mk…), which takes no new repositories once it starts
moving acme/app to node 2
moved acme/app to node 2 (1 moved)
acme/old stays: in the trash: restore it (and drain again) or purge it
moving acme/web to node 3
the move of acme/web failed: rolling it back
acme/web not moved: …

At the end come three lists, moved (N):, stay (N): and not moved (N):, each repository with why it stayed or wasn’t moved, and the drain’s last message, such as “drained node 1: moved 11, 1 stays, 1 not moved”. Nodes are named by key ID (“node 2”) wherever the output mentions one of the host’s. A drain that failed (five failed moves in a row, the node no longer active, nowhere left to move to) exits with an error that says so; with --abort, an aborted drain exits 0. Ctrl-C stops following, not the drain.

It refuses a node the host doesn’t have, a --to that names one, and a node with a drain already running. When the node isn’t active (retired or revoked) or no other active node takes repositories, the drain’s first step fails and the command prints why. Drains of different nodes can run at the same time. --undo prints “takes new repositories again”, or “wasn’t draining”. See Drain a node.

moves#

Lists the host’s drains, then its moves, newest first. A drain’s line has its ID, the node, its state, how many repositories it moved, how many stay and how many weren’t moved, the move in flight and when it started; a move’s has its ID, repository, from and to, state, step and when it started. The latest message is under each, and a refused abort’s reason. Every unfinished drain and move is listed, with the newest finished ones: 10 drains and 50 moves. A drain’s moves that went through aren’t listed, since the drain counts them; those that failed are.

1762992000000-3f9a0c1d2e4b drain node 1 running: 3 moved, 1 stays, 0 not moved, moving acme/app → node 2 (started 2026-11-13 09:20)
moru-node moves

restore-repos#

Takes over a revoked or retired node’s repositories from a backup of that node, on this node. Run it on the node that should hold them, beside serve: the running node unpacks them, writes the host’s revocation into each first when the node was revoked, puts them in place and has them placed here. Repositories placed on another node since the backup, or in the old node’s trash, are skipped. It follows the restore and prints what happened to each repository.

moru-node restore-repos [OPTIONS] <BACKUP>
Flag
--repo <REPO>Only this repository (repeatable). Default: every one in the backup.
--no-waitHand it to the running node and return.
--abort <ID>Abort the restore with this ID, which the command printed. Repositories it already put in place stay.
moru-node restore-repos old-node.tgz
moru-node restore-repos old-node.tgz --repo acme/timetable

The node must be active and hold repositories: a standalone node, and a control node with role control, refuse it. The backup must be of a node the host has retired, or revoked with a time. The data directory’s disk needs free space of three times the backup’s size plus 64 MiB (the copied backup is kept while its repositories are unpacked beside it), or the command refuses before it copies anything. While a restore of the same old node’s repositories hasn’t finished on this node, it refuses and names that restore: wait for it or abort it first. Restore its repositories from a backup… in Settings → Network does the same with an upload, up to --max-restore-upload.

People#

create-user#

Creates a person’s account and prints a single-use link, valid for 24 hours, where they set their password. Also how you make the first admin without the setup link.

moru-node create-user [OPTIONS] <HANDLE>
Flag
--adminMake them an admin. Default: member.
--resetThe account exists: issue a new link, and revoke its password and tokens. For a forgotten password when no admin can sign in.
--url <URL>Base URL of the web UI, for the printed link. Variable MORU_PUBLIC_URL, default http://127.0.0.1:7070.
moru-node create-user jon
moru-node create-user mira --admin
moru-node create-user mira --reset

create-user-token#

Mints a token for a person, for scripts and tests, and prints a sign-in link with it. If the handle has no account, it creates one as an admin, with a did:key. People who sign in themselves get create-user instead.

moru-node create-user-token [OPTIONS] <HANDLE>
Flag
--ttl <TTL>How long the token lasts. Default 7d.
--url <URL>Base URL for the printed sign-in link. Variable MORU_PUBLIC_URL, default http://127.0.0.1:7070.

The token goes to stdout and everything else to stderr, so TOKEN=$(moru-node create-user-token mira) captures only the token.

Repositories#

init-repo#

Creates a repo, private unless --public. Its owner must be a person’s handle or an organization: only they get in.

moru-node init-repo [OPTIONS] <REPO>
Flag
--publicReadable by anyone, signed in or not.
--allow-unownedAllow an owner that is neither a person nor an organization. The repo then has no admin until a site admin adopts it by creating an organization of that name.
moru-node init-repo acme/timetable

import-repo#

Imports a repo, with all its changes and requests, from another Moru node or any git URL (a mirror clone). Private unless --public. Before the repo is served, it writes the revocations of this host’s node keys that the copy lacks. Prints a report as JSON: what was imported, the hosts the repo names (hosts: known to this node or new, revocations the copy lacked, a conflict between its DID documents) and warnings. See How trust works.

moru-node import-repo [OPTIONS] <REPO> <URL>
Flag
--token <TOKEN>A token for the source node. Better passed in MORU_IMPORT_TOKEN.
--publicReadable by anyone.
--allow-unownedAs for init-repo.
MORU_IMPORT_TOKEN=… moru-node import-repo acme/timetable https://other.example.com/git/acme/timetable.git

verify#

Checks the attestations of a change: each revision’s signature, what it attests, and whether the signer is trusted. CI results (ci-run attestations) are listed too, each with whether it counts toward the repo’s required CI jobs; they don’t change the exit status. Exits with status 1 unless every revision has a valid, trusted attestation. See Provenance.

moru-node verify [OPTIONS] <REPO> <CHANGE_ID>
moru-node verify acme/timetable <change-id>

repo-policy#

Shows or sets a repo’s merge rules.

moru-node repo-policy [OPTIONS] <REPO>
Flag
--require-pinned <true or false>Merge agents’ changes only from runs with a pinned Claude Code version.
--required-ci <LIST>CI jobs that must pass on a change’s latest revision, as comma-separated <workflow>/<job> names (checks/test). "" requires none.
moru-node repo-policy acme/timetable                              # show
moru-node repo-policy acme/timetable --require-pinned true        # set
moru-node repo-policy acme/timetable --required-ci checks/test    # require job test of .moru/workflows/checks.yml

Links a repo to a GitHub repo: its branches follow GitHub, and approved changes become pull requests there. Creates the repo from GitHub if it doesn’t exist. See GitHub. When it fetches Moru’s data from GitHub, it writes the revocations of this host’s node keys that the data lacks, and prints each one.

moru-node link-github [OPTIONS] <REPO> <GITHUB>

<GITHUB> is owner/name on GitHub.

Flag
--token-file <TOKEN_FILE>A file holding a fine-grained token for that repo, with Contents and Pull requests: read and write. Or set MORU_GITHUB_TOKEN.
--direct-pushPush approved changes straight to the target branch instead of opening a pull request.
--push-moru-refsAlso push Moru’s data (refs/moru/objects and changes) to GitHub.
--git-url <GIT_URL>Override the git URL. Default https://github.com/<github>.git.
--api-url <API_URL>Override the REST API base. Default https://api.github.com.
--publicMake a repo the link creates readable by anyone. Default private.
--allow-unownedAs for init-repo.
moru-node link-github acme/timetable acme/timetable --token-file github-token.txt

Stops following GitHub: removes the link and its stored token, withdraws changes waiting on GitHub as pull requests (so they can be merged here), and protects the default branch.

moru-node unlink-github [OPTIONS] <REPO>
Flag
--no-protectLeave the default branch unprotected.

list-deleted#

Lists deleted repos that can still be restored, latest first: each one’s ID, name, who deleted it and when it will be purged.

moru-node list-deleted

restore-repo#

Restores a deleted repo under its own name, by the ID list-deleted prints.

moru-node restore-repo <id>

Runners and agents#

create-runner-token#

Registers a runner and prints its token. Most runners register themselves with a one-time code from the UI instead; see Add a runner.

moru-node create-runner-token [OPTIONS] --key <KEY> --owner <OWNER> <NAME>
Flag
--key <KEY>Required. The runner’s signing key, a did:key (moru-runner key prints it).
--owner <OWNER>Required. The person the runner works for. It runs only that person’s jobs.
--label <LABELS>A pool the runner belongs to (repeatable). Profiles can require one.
--ttl <TTL>How long the token lasts. Default 90d.
moru-node create-runner-token jon-laptop --key did:key:z6Mk… --owner jon
moru-node create-runner-token jon-build-1 --key did:key:z6Mk… --owner jon --label build

revoke-runner#

Revokes every token of a runner. It stops getting work at once.

moru-node revoke-runner jon-laptop

list-runners#

Lists registered runners: name, whether revoked, DID, owner, labels and number of tokens. A runner registered before every runner had an owner shows owner=none (can't lease): it gets no work until create-runner-token gives it an owner (same name and key, plus --owner) and it restarts with the new token.

moru-node list-runners

pin-harness#

Pins the Claude Code version on Claude profiles: all of them, or those named with --profile. Runners download that version from Anthropic and check it against Anthropic’s manifest.

moru-node pin-harness [OPTIONS] <VERSION>

<VERSION> is MAJOR.MINOR.PATCH.

Flag
--profile <PROFILES>A profile to pin (repeatable). Default: all Claude profiles.
moru-node pin-harness 2.1.296

Data#

backup#

Writes a gzipped tar of everything that can’t be rebuilt: repos as git bundles, keys, accounts and configuration. Safe while the node runs. The archive holds unencrypted keys: encrypt it before you store it. See Backups.

moru-node backup [OPTIONS] <OUT>

<OUT> is a file, or - for stdout.

moru-node backup - | age -r age1… > moru-$(date +%F).tgz.age

On a host with many nodes, the backup holds what that node keeps. A control node’s holds the host-wide state and keys, as a single node’s does, plus its unfinished moves, revocations and restores. A repo node’s holds its repositories and their settings, but not its node key, its host identity or its copies of the control node’s state. A copy on its way to a node (being moved there or restored there and not yet in place) isn’t in that node’s backup. See Backups.

restore#

Recreates the data directory from a backup. The directory must be empty; the node rebuilds the index when it starts.

  • A repo node’s backup restores to a node that joins the host as a new node and takes over the old one’s repositories: start it with --role repo and a node code (join) or an enrollment token. Stop the old node first. See Restore a repo node.
  • A control node’s backup: moves, revocations and restores that hadn’t finished when it was taken come back failed, and the command says how many. Check them with moves and start again what’s still needed.
moru-node restore [OPTIONS] <INPUT>

<INPUT> is a file, or - for stdin. From a file, it first checks that the data directory’s disk has free space of twice the backup’s size plus 64 MiB, and refuses otherwise; from stdin the size isn’t known, so there’s no check.

moru-node --data /var/lib/moru restore moru-2026-11-10.tgz

rebuild-index#

Deletes the index and rebuilds it from the repos on disk, then prints what it found as JSON. Stop the node first.

moru-node rebuild-index
Command menu
Search for a page, repository, change or request, or run a command