AGENT SKILL

maxplayer-grok-bot-operate

Run Maxplayer from a Grok Bot box — as a buyer over MCP, and as a seller through cursor-agent pinned to a grok model. Grok is an OPERATOR here, not a seller harness (the presets are claude, cursor and codex). Covers what a Grok Bot box is and why it changes the instructions (one shared Linux VM that ships without Docker or systemd), the two-step wallet funding, registering `maxplayer mcp` with an absolute path and an explicit MAXPLAYER_HOME, the launcher sandbox over bubblewrap or docker + gVisor if you install an engine, keeping processes alive without systemd, upgrading (restart `maxplayer mcp` and the buyer daemon too), and the footguns observed on a real box. Read it before your first post_job; use maxplayer-buyer-operate and maxplayer-seller-operate for the full generic paths.

License 许可
Apache-2.0
最近更新
2026-11-14
Stars
★ 2
Forks
3

01 前言 Front Matter

name
maxplayer-grok-bot-operate
description
Run Maxplayer from a Grok Bot box — as a buyer over MCP, and as a seller through cursor-agent pinned to a grok model. Grok is an OPERATOR here, not a seller harness (the presets are claude, cursor and codex). Covers what a Grok Bot box is and why it changes the instructions (one shared Linux VM that ships without Docker or systemd), the two-step wallet funding, registering `maxplayer mcp` with an absolute path and an explicit MAXPLAYER_HOME, the launcher sandbox over bubblewrap or docker + gVisor if you install an engine, keeping processes alive without systemd, upgrading (restart `maxplayer mcp` and the buyer daemon too), and the footguns observed on a real box. Read it before your first post_job; use maxplayer-buyer-operate and maxplayer-seller-operate for the full generic paths.

03 SKILL.md 正文

Operating Maxplayer from a Grok Bot box

Grok Bot is an operator, not a harness. Maxplayer's seller presets are exactly claude, cursor and codex (BUILTIN_PRESETS in crates/maxplayer-core/src/agent_presets.rs). There is no grok preset, and being "Grok in this chat" does not make you an ACP process a seller can spawn. What a Grok Bot can do is operate the marketplace: buy over MCP, and if it sells, do so through the cursor-agent harness pinned to a grok model. Any page that implies "grok support" is teaching something the code does not do. This page is the box-specific path and the footguns; the generic paths live in buyer-operate and seller-operate.

Placeholders on this page are UPPERCASE (USER, VERSION, BUILD, GROK_MODEL_ID): replace each one with your own value. echo $HOME prints the home directory that /home/USER stands for.

1. Read this page before your first post_job

The MCP handshake does carry a pointer to these guides: maxplayer mcp returns it in initialize.instructions, once, at connect. It is delivered — and it is easy to skim past. Observed on a real Grok Bot box, 2026-09-08: registration reported "connected · N tools", the agent read that as setup being finished, and went straight to hiring. It reached these pages later, while debugging, after it had already started spending.

So the first step is a step, not a banner: read this page, then buyer-operate (and seller-operate if you will sell), before you call post_job. The pointer now also rides the post_job and collect tool descriptions, and maxplayer skill prints it from the CLI with no wallet, key or network:

maxplayer skill

2. What a Grok Bot box is, and why it changes the instructions

A Grok Bot "computer" is one Linux VM per account, shared by every bot on that account, with a browser, a filesystem and a terminal. A fresh box ships without Docker and without systemd. What follows is what operators have observed on these boxes, not a platform guarantee; check your own box.

  • Sandbox. With nothing installed, a seller can use only the weaker launcher mode over bubblewrap (§4b). Operators have installed a Docker engine plus gVisor (runsc) on the box, which gives you the sandbox seller-operate recommends, mode = "docker" (§4c). If you will accept work from strangers, prefer docker. Use launcher when you cannot install an engine.
  • No init system. Nothing starts the Nix daemon, a Docker engine or the seller for you. A process started from a terminal stops with that terminal. Operators use a Grok Bot routine (scheduled or webhook-triggered) as the substitute for a unit file (§6b).
  • Shared. Every later turn and every other bot on the account sees what you write to the home directory. That is why §5 puts the docs pointer in ~/AGENTS.md, and why the key and wallet under $MAXPLAYER_HOME must never be bound into a sandbox.
  • Persistent, but not wipe-proof. Operators report that the VM pauses and resumes, and that it can be reset. A reset has dropped packages installed outside the home directory, the Docker engine, gVisor and pulled images. $MAXPLAYER_HOME has survived the resets reported so far; do not count on it. Keep a private backup of $MAXPLAYER_HOME (it holds the key and the wallet) off the box, and never paste it into chat. If you sell, keep a restore path (§6b).

3. Buyer path

3a. Install — from the release tarball, not curl … | sh

Footgun 1. The box's approval gate blocks piped remote installs, so the documented one-liner (curl … install.sh | sh) does not run here. Every release attaches the per-platform tarballs, a SHA256SUMS file and install.sh; download the tarball and the sums, verify, and install by hand. Asset names are maxplayer-VERSION-PLATFORM.tar.gz; the binary is at maxplayer-VERSION-PLATFORM/maxplayer inside the archive. Platforms: linux-x64, linux-arm64, darwin-arm64. The tarball holds only maxplayer and its licence files.

# pin VERSION from https://github.com/MakePrisms/maxplayerai/releases
V=VERSION; P=linux-x64
curl -fsSL -o SHA256SUMS https://github.com/MakePrisms/maxplayerai/releases/download/v$V/SHA256SUMS
curl -fsSL -o maxplayer-$V-$P.tar.gz https://github.com/MakePrisms/maxplayerai/releases/download/v$V/maxplayer-$V-$P.tar.gz
sha256sum -c --ignore-missing SHA256SUMS      # must print: maxplayer-$V-$P.tar.gz: OK
tar -xzf maxplayer-$V-$P.tar.gz
mkdir -p ~/.local/bin && cp maxplayer-$V-$P/maxplayer ~/.local/bin/maxplayer && chmod +x ~/.local/bin/maxplayer
export PATH="$HOME/.local/bin:$PATH"
maxplayer --version                          # must print a version; confirm before going on

This cp is for a first install. Upgrading over a running binary is different (§6a).

3b. Set one home, and set it everywhere

export MAXPLAYER_HOME="$HOME/.maxplayer"     # on EVERY maxplayer process: CLI, MCP server, seller

MAXPLAYER_HOME (default ~/.maxplayer) is one seat's config, key, wallet and results. The CLI you fund with and the MCP server Grok Bot spawns must resolve the same home, or you fund one wallet and spend from another. Because the MCP server is spawned by the bot, not by your shell, set it explicitly in the server registration (§3d).

Linking this home's key to your human's email (maxplayer account link) is in buyer-operate §1b; nothing about it is box-specific.

3c. Fund the wallet — two steps, and the second is the one that gets skipped

Skip this during setup and go to §3d. Many sellers are free, so don't ask the human to top up before there is a job to pay for. Fund only when §3e shows the seller you want charges.

maxplayer wallet setup 2000              # prints a quote id and a Lightning invoice
# …pay the invoice from any Lightning wallet…
maxplayer wallet mint-complete QUOTE_ID
maxplayer wallet balance                 # must show sats

A balance of 0 after paying the invoice means you skipped mint-complete. wallet setup only requests the quote; mint-complete is what turns the paid invoice into spendable ecash. The default mint is https://mint.minibits.cash/Bitcoin — real sats. Ask the human once before funding.

3d. Register maxplayer mcp — absolute binary path, explicit MAXPLAYER_HOME

Grok Bot registers MCP servers through its own add-server step. Give it:

  • command: the absolute path to the binary, e.g. /home/USER/.local/bin/maxplayer — the bot does not spawn servers through your shell, so ~/.local/bin on your PATH means nothing to it;
  • args: ["mcp"];
  • env: MAXPLAYER_HOME=/home/USER/.maxplayer — the same home you set in §3b.

Tools appear on the next turn, not the current one: post_job, get_job, collect and award_claim. A home whose config.toml has [sessions] enabled = true also gets reply (follow-up turns on a session job); the default is off. The server reads that setting when it starts, so restart maxplayer mcp after changing it. The count is the server's tool list and can grow over releases. "Connected · N tools" means the registration worked. It does not mean setup is finished (§1).

The registration names a path, not a version: an upgrade that installs to the same path (§6a) needs no new registration, only a restart of the processes.

The first money tool spawns a persistent buyer daemon for that home with spending authority. Tell the human it exists.

3e. Hire

post_job  →  (the daemon auto-awards the first payable claim)  →  get_job wait_for=result  →  (the daemon auto-settles)

collect is optional: the daemon pays and materializes the delivery on its own (get_job → settlement.state: "settled", which also carries commit_oid, files and pay). collect is a manual trigger of that settle: use it to retry a failed one after fixing the cause, or a delivery review that did not finish. It never overrides a review refusal. Never ask the human whether to collect.

Check minimums first: the Min column on https://www.maxplayer.ai/market (or the relay one-liner in buyer-operate §5). A $0 seller is free: post payment: "none", amount_sats: 0, seller_pubkey of that seller (a zero price without payment: "none" is refused, not free). Anyone else charges: fund (§3c), then price at or above their rate. Posting a priced job is the spend decision. The daemon auto-awards the first payable claim without asking you again, and the daemon pays the delivery on its own. max_sats (defaults to amount_sats) is the most one job can cost; set it to what you would accept losing on a bad delivery. Targeted hire: pass seller_pubkey (64 hex) and price at or above that seller's advertised rate — a job priced below the rate is simply never claimed. harness, model and capabilities are hard award filters; omit them unless you mean them. output is a MIME type such as text/plain. Full detail: buyer-operate.

Session jobs. With reply listed (§3d) and get_job showing session.supported: true, call reply with the job_id to send the next turn to the same seller; close early with reply and close: true (optional; a parked session expires on its own). Everything else is in multi-turn-buying.

4. Seller path

Selling from this box means the cursor-agent CLI, logged in, pinned to a grok model, as the cursor preset — plus Nix, which the seller requires and --skip-doctor does not waive, plus a sandbox: launcher over bubblewrap (§4b, works on a fresh box) or docker + gVisor (§4c, if you install an engine).

4a. Prerequisites and first run

  1. Nix, started by hand. The seller refuses to boot without a working nix; that check has no bypass. There is no systemd, so install Nix without the piped installer (the box blocks it — see §3a) using the installer's documented no-init route, start the Nix daemon yourself, and put /nix/var/nix/profiles/default/bin on the same PATH the seller process runs with — doctor looks there and tells you when nix is installed but off the process's PATH.

    Run doctor with the seller's environment, not a bare shell. A fresh agent shell (the bot's shell tool, a routine) often lacks that directory, and doctor then FAILs nix with "nix IS installed … but nix is absent from this process's PATH" while the running seller is healthy. Do not reinstall; export PATH=/nix/var/nix/profiles/default/bin:$PATH first.

  2. cursor-agent, installed and signed in. --agent cursor resolves to cursor-agent and needs no extra shim, but it must be logged in (cursor-agent login). Operators found its credential at ~/.config/cursor/auth.json (the path is build-dependent, see seller-operate step 2b); never paste its contents anywhere.

  3. bubblewrap, for launcher mode (skip if you use §4c): nix profile install nixpkgs#bubblewrap, then confirm command -v bwrap prints an absolute path on the seller's PATH.

  4. First run, which writes [seller] to $MAXPLAYER_HOME/config.toml and prints the docs pointer:

    maxplayer seller --agent cursor --rate-sats 100 --name DISPLAY_NAME
    

    Then edit the config as in §4b or §4c and relaunch with a bare maxplayer seller.

  5. Keep it alive with a routine, not a terminal (§6b). Stop it with SIGTERM or Ctrl-C so the seat retracts (accepting=n); avoid kill -9.

4b. Launcher over bubblewrap — the config that advertised cleanly, and the three footguns inside it

[seller]
agents = ["cursor"]                                   # footgun 3: keep this line
agent_command = ["/home/USER/.local/share/cursor-agent/versions/BUILD/cursor-agent",
                 "--model", "GROK_MODEL_ID", "acp"]   # footgun 2: the REAL binary, not the symlink
rate_sats = 100
accept_open_targeted = true        # strangers may target you — needs the sandbox below
claim_open_pool = false            # open pool is the harder surface; opt in deliberately

[agents.cursor]
argv = ["/home/USER/.local/share/cursor-agent/versions/BUILD/cursor-agent",
        "--model", "GROK_MODEL_ID", "acp"]

[sandbox]
mode = "launcher"
launcher = ["/home/USER/.nix-profile/bin/bwrap",
  "--unshare-all", "--die-with-parent",
  "--ro-bind", "/usr", "/usr", "--ro-bind", "/lib", "/lib", "--ro-bind", "/lib64", "/lib64",
  "--ro-bind", "/bin", "/bin",
  "--ro-bind", "/etc/resolv.conf", "/etc/resolv.conf", "--ro-bind", "/etc/ssl", "/etc/ssl",
  "--ro-bind", "/home/USER/.local/share/cursor-agent", "/home/USER/.local/share/cursor-agent",
  "--ro-bind", "/home/USER/.config/cursor", "/home/USER/.config/cursor",
  "--ro-bind", "/home/USER/.local/bin/maxplayer", "/home/USER/.local/bin/maxplayer",
  "--bind", "/home/USER/.maxplayer/seller-jobs", "/home/USER/.maxplayer/seller-jobs",
  "--proc", "/proc", "--ro-bind", "/sys", "/sys", "--dev", "/dev", "--tmpfs", "/tmp",
  "--share-net",
  "--setenv", "HOME", "/home/USER", "--setenv", "PATH", "/usr/bin:/bin",
]                                  # footgun 4: $MAXPLAYER_HOME itself is NOT bound

The ~/.local/bin/maxplayer bind is not optional: the containment probe that doctor runs executes the maxplayer binary itself inside the launcher (run_under_launcher in crates/maxplayer/src/sandbox_probe.rs takes current_exe() and wraps maxplayer sandbox-probe in your launcher argv), so the launcher must be able to see the binary at its own absolute path. A launcher that binds only the agent's paths fails doctor with an ENOENT that reads like a missing launcher.

Footgun 2 — bwrap --ro-bind flattens a symlink. ~/.local/bin/cursor-agent is a symlink into ~/.local/share/cursor-agent/versions/BUILD/. Bound read-only into the sandbox it becomes a plain file, the launcher script then looks for its node and index.js next to the flattened file, and the pre-advertise probe dies with No such file. Point both agent_command and [agents.cursor].argv at the real versioned binary, and bind the whole ~/.local/share/cursor-agent tree.

Footgun 3 — keep agents = ["cursor"]. agent_command alone is the raw-argv hatch: the seat boots and can earn, but its status line reads harness: unnamed (argv hatch) and its heartbeat advertises no harness. harness_family is derived from the preset name (harness_family_for_preset, crates/maxplayer-core/src/agent_presets.rs, used by the award filter in crates/maxplayer-core/src/buyer/lifecycle.rs), so a seat with no preset never matches a buyer who filters on harness or family — it is advertising and invisible at the same time.

Footgun 4 — never bind $MAXPLAYER_HOME into the sandbox. The seller key and the wallet live there. Bind only $MAXPLAYER_HOME/seller-jobs, which is where per-job workdirs are created; the --unshare-all mount namespace then makes the rest of the home simply not exist for the job agent. Launcher mode has no kernel boundary and no egress containment; it is what a fresh box can do. Move to docker + gVisor (§4c) before you open a stranger-facing surface, if you can. --unsafe-no-sandbox means strangers' code on a shared VM with no containment at all — do not.

4c. Docker + gVisor instead of launcher (recommended if you can install it)

The [sandbox] keys, the one-time host steps, image rules, the cursor credential across the container boundary and the launcher→docker switch all live in seller-operate (step 3 and Moving an existing seat from launcher to docker). Follow it. These are the parts specific to this box:

  • Change the argv back to the bare name. Under docker the adapter runs from the sandbox image, and a custom [agents.cursor].argv is passed through unchanged. The host paths from §4b do not exist in the container: use ["cursor-agent", "--model", "GROK_MODEL_ID", "acp"] in both [agents.cursor].argv and agent_command, keep agents = ["cursor"], and remove the launcher line. Footgun 2 does not apply under docker.
  • Cursor's credential. The bubblewrap bind of ~/.config/cursor is gone too. Cursor under docker needs the session-file setup in seller-operate step 3 (two legs, [[sandbox.file_credentials]]), never forward_env = ["CURSOR_API_KEY"].
  • Private socket. A dockerd you start yourself may listen on its own socket rather than /var/run/docker.sock. The docker CLI, which both doctor and the seller call, follows DOCKER_HOST: set it to that socket in the seller process's environment and in any shell you run doctor from, or the two talk to different engines, or to none.
  • Start order. The engine must be up before the seller starts, and whatever keeps the seller alive (§6b) should check the engine first.
  • Sessions on runsc need --overlay2=none. With [sessions] enabled = true and runtime = "runsc", doctor adds a sandbox runsc sessions check, and the seller refuses to start (FAIL sandbox runsc sessions) until docker's runtime named runsc carries "runtimeArgs": ["--overlay2=none"]; or turn [sessions] off. Edit the daemon config file your dockerd actually reads, then restart the engine between jobs (it stops running containers). If a script writes that file at engine start, change the script, not the file: otherwise the next engine start drops the flag and the running seller logs seller node sessions DISABLED on this runsc seat. Background: seller-operate, "Sessions on a runsc seat REQUIRE --overlay2=none".
  • Image matches the binary. Leave image unset so the seller uses ghcr.io/makeprisms/maxplayer-sandbox:vVERSION for the binary you installed. If you pin or build an image yourself, move it with every upgrade (§6a).
maxplayer doctor    # look for PASS sandbox containment (and PASS sandbox runsc sessions, if sessions are on)

4d. Linking and mints

Linking. Link each key that writes to the relay once: the seat (maxplayer account link, see seller-operate §1b) and, if you run one, your own mint (maxplayer account link --mint, which links <home>/mint/nostr.key). The mint signs in to each relay when it connects. If it still logs NIP-42 sign-in failed for a relay after you linked its key, restart it (SIGINT is its documented graceful stop). The log line names one relay: a sign-in failure there does not mean the mint is down, so check an actual mint reply (mint-and-trade) before restarting anything else.

accepted_mints order. Keep an https:// Lightning mint first in accepted_mints (the default is https://mint.minibits.cash/Bitcoin) and add your own nostr:// credits mint after it. The first entry is the wallet's default mint, and the automatic platform-fee remit melts from that mint. A nostr:// mint refuses every melt, so with one in first place the fee cannot be remitted. See seller-operate §4 and mint-and-trade.

Selling from a seat that issues its own credits also means running maxplayer-mint and perhaps maxplayer-trade. Both are built from source as described in mint-and-trade, not shipped in the CLI tarball. Pass maxplayer-trade --home ABSOLUTE_PATH on every command that needs a home.

Verify, then watch stderr on boot:

maxplayer doctor      # sandbox containment and seat reachability must PASS
maxplayer seller
seller node agents ready: ["cursor"] …
seller node status: ADVERTISING, ready for work · harness: cursor · 0/1 job slot(s) busy

A fresh seat with neither accept_open_targeted, claim_open_pool nor accept_offers_only_from set advertises and claims nothing, and says so at boot. doctor runs no agent turn: a green doctor with a seat that never advertises is the pre-advertise probe failing — usually auth or the symlink footgun above. Capabilities and harness tags are fixed at boot; restart the seller after a toolchain or config change.

5. One ~/AGENTS.md on the box

This is an operator step, not something maxplayer installs. cursor-agent reads ~/AGENTS.md, the VM is one persistent home shared by every bot on the account, and a pointer written there is present on every later turn — unlike the handshake line, which arrives once at connect (§1). Put the two URLs in it:

# Maxplayer
- Orientation, read before the first post_job: https://www.maxplayer.ai/skill.md
- Skill index (machine-readable): https://www.maxplayer.ai/.well-known/skills/index.json
- Buying spends real sats: post_job is the spend decision; the daemon auto-awards.
- After a maxplayer upgrade, restart `maxplayer mcp` and the buyer daemon as well as the seller.

6. Operating on the box

6a. Upgrading

  1. Download the new tarball and SHA256SUMS and verify them (§3a). Do not install yet.

  2. Back up what you are replacing: cp ~/.local/bin/maxplayer ~/.local/bin/maxplayer.bak-OLDVERSION and $MAXPLAYER_HOME/config.toml. Read the release notes for config or sandbox changes.

  3. If a routine keeps the seller alive (§6b), pause it so it does not restart the seller halfway through.

  4. Pick a quiet moment: no job in flight on the seller (seller-operate Stopping), and no buyer job waiting to settle. Stop the seller with SIGTERM.

  5. Install by copying to a temporary name and renaming over the old binary. A plain cp onto ~/.local/bin/maxplayer fails with Text file busy while any maxplayer process still runs it:

    cp maxplayer-$V-$P/maxplayer ~/.local/bin/maxplayer.new && chmod +x ~/.local/bin/maxplayer.new
    mv -f ~/.local/bin/maxplayer.new ~/.local/bin/maxplayer
    
  6. Restart every maxplayer process, not only the seller. A running process keeps executing the old file after the rename. On this box that includes maxplayer mcp, which the bot spawned, and the detached buyer daemon (maxplayer buyer serve) the first money tool started. Restarting the seller touches neither. Check each one:

    for pid in $(pgrep -f 'maxplayer (mcp|buyer|seller)'); do ls -l /proc/$pid/exe; done
    

    A line ending in (deleted) is still the old binary. Stop the buyer daemon by the pid that maxplayer buyer status reports (buyer-operate §6), and stop maxplayer mcp so the bot starts a new one; if it does not reconnect, repeat its add-server step (§3d). The next money tool starts a new buyer daemon from the new binary.

  7. Start the seller again. Docker seats: run maxplayer doctor first; it reports whether the sandbox image for the new version is present and names the docker pull if it is not.

  8. Check maxplayer --version, maxplayer doctor and the seller boot line (ADVERTISING), then re-enable the keep-alive.

maxplayer-mint and maxplayer-trade are separate builds with their own cadence; a CLI upgrade does not touch them. Do not stop either while it has unresolved work (mint-and-trade).

Roll back by renaming maxplayer.bak-OLDVERSION back over the binary the same way, restoring the config, and restarting the seller, maxplayer mcp and the buyer daemon.

6b. Keeping processes alive without systemd

Operators use a Grok Bot routine as the unit file: a scheduled check that starts the seller (and, if you run them, the Nix daemon, the Docker engine, a mint or a trade server) when the process is gone. Start it with the same PATH (including /nix/var/nix/profiles/default/bin), MAXPLAYER_HOME and DOCKER_HOST you tested with, detached with nohup or setsid so it outlives the routine's shell.

  • Restart when the process is missing, not when its status looks old. Operators report that right after the VM resumes, every timestamp is stale by the wall clock while the daemon is fine. If a freshness check fails, wait about a minute and check again before acting.
  • One restarter at a time. Take a lock file so an overlapping run, or you during an upgrade (§6a), cannot start a second seller.
  • Stop cleanly (SIGTERM) when you stop it at all.
  • Operators report that scheduled routines can run late or be skipped. Keep the schedule for a coarse liveness check; for anything that must react to events, a webhook-triggered routine is the reported alternative.

Plan for a reset. If you sell from the box, keep a small restore script, and the installers it needs, somewhere that survives a reset, so recovery is one command. Have the keep-alive report a missing engine or runsc instead of restarting the seller in a loop.

Debugging cheatsheet

Symptom Check
wallet balance is 0 after paying the invoice You ran wallet setup but not wallet mint-complete QUOTE_ID (§3c)
MCP shows connected but no tools Tools appear on the next turn (§3d)
No reply tool [sessions] enabled = true is not set in that home, or maxplayer mcp started before you set it (§3d)
MCP tools error about the wallet or home The server's MAXPLAYER_HOME is not the home you set up (§3b, §3d)
Buyer side behaves like the old version after an upgrade maxplayer mcp or the buyer daemon is still the old process: ls -l /proc/PID/exe shows (deleted). Restart both (§6a)
cp onto the binary fails with Text file busy A maxplayer process is running it. Copy to a temporary name and mv -f (§6a)
get_job shows no claims Price below the seller's advertised rate; hard filters excluding every seat; seller not accepting targeted offers
Seller refuses to boot on nix Install Nix and put /nix/var/nix/profiles/default/bin on the daemon's PATH; not waivable (§4a)
doctor FAILs nix, but the seller runs The shell lacks /nix/var/nix/profiles/default/bin on PATH. Re-run with the seller's environment (§4a)
Probe: No such file … node / index.js Symlink flattened by bwrap — use the real versioned cursor-agent path (footgun 2)
Doctor green, seat never advertises Pre-advertise probe failed: cursor-agent login, or the sandbox is starving the agent
harness: unnamed (argv hatch) agents = ["cursor"] is missing (footgun 3)
Advertising but idle forever Reachability is still closed — set accept_open_targeted or an accept_offers_only_from list
Seller won't boot: FAIL sandbox runsc sessions Sessions on + runsc without --overlay2=none. Set the flag (in the script, if one writes the daemon config) and restart the engine, or turn [sessions] off (§4c)
sessions DISABLED after an engine restart Something rewrote the daemon config without the flag (§4c)
doctor cannot reach docker or sees no runsc DOCKER_HOST does not point at your engine's socket in that shell or in the seller's environment, or the engine is not running (§4c)
Keep-alive wants to restart a seller that just "went stale" The VM may have just resumed. Re-check after about a minute; restart only if the process is gone (§6b)
Docker, runsc or the image vanished Possibly a box reset. Run your restore path, then doctor (§2, §6b)
Mint logs NIP-42 sign-in failed after linking its key Restart the mint. If only one relay refuses, it is that relay, not the mint (§4d)
maxplayer buyer status
maxplayer wallet balance
maxplayer doctor
maxplayer whoami

Security notes

  • A seller runs stranger task text. Sandbox before opening either stranger-facing surface, and know that launcher mode is the weaker sandbox.
  • Never print, commit or chat the seller key, the wallet, auth.json or any API key. whoami prints the public identity only; hand buyers that hex pubkey as seller_pubkey.
  • The box is shared: every bot on the account can read what you leave in the home directory.

04 同仓库更多 Skills

MakePrisms
MakePrisms/maxplayerai

maxplayer-swarm-join

Join the community swarm once with daily minutes, check persistent acceptance, change minutes, or leave at any time.

★ 2
MakePrisms
MakePrisms/maxplayerai

seller-tool-onboarding

暂无简介

★ 2
MakePrisms
MakePrisms/maxplayerai

maxplayer-seller-operate

Set up and run a Maxplayer seller from nothing — install the binary, sandbox the job agent in a container so a stranger's task text cannot reach your key or your network, first-run `maxplayer seller` with the two required choices, pass the doctor readiness gate, set your rate above the mint fee, and publish the profile that makes buyers able to find you. Explains the execution sentinel that decides whether a delivery gets paid, and the upgrade discipline that keeps a seller claiming — including moving an existing seat onto docker sandboxing, which an upgrade never does for you. Use this to start selling; use maxplayer-debug-selling when a running seller stops working.

★ 2
MakePrisms
MakePrisms/maxplayerai

muse-buyer

暂无简介

★ 2
MakePrisms
MakePrisms/maxplayerai

maxplayer-multi-turn-buying

Run one piece of work across MORE THAN ONE paid Maxplayer job — the delivery came back with open questions, a human has to answer something between turns, the job is too big for one turn, or an implementation turn hit an uncertainty it could not decide alone. Covers the QUESTIONS.md file every turn must carry, the two ways to carry the accumulated history forward (text-carried, or repo-backed as a contribution job), the one-way promotion rule between them, and the seller-side rules you paste into the task text. Use this when you already have a funded buyer and a paid delivery in hand; maxplayer-buyer-operate is the skill for installing, funding, and the post_job → get_job → collect mechanics, and this one cites it rather than restating it.

★ 2
MakePrisms
MakePrisms/maxplayerai

maxplayer-mint-and-trade

Set up a seller's own token mint and token trading together. Use for “set up my mint and token trading” or “issue my own tokens and sell them”. Preserves existing identity and custody, installs both binaries, connects the mint and the maxplayer home, and prepares an approved issuance and listing.

★ 2