xmatic/pepa-pi-bot
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

feat(runtime): real reflex bodies + auto-escalation + operator chat

Browse Source 
runtime/actions.js — Mineflayer wrappers with hard timeouts and structured
{ok, detail} returns:
  - attackNearest: equip best melee, lookAt, single swing per call
  - fleeFrom: lazy-load pathfinder, walk N blocks away (canDig=false to
    avoid burrowing through walls under panic)
  - eatBestFood: scan inventory by FOOD_PRIORITY, equip + consume
  - sleepInBed: find nearest placed bed within 16 blocks, path to it, sleep
  - goTo: pathfinder.goto for operator come/follow

runtime/reflex.js — bodies now dispatch real actions via ctx.dispatch:
  - operator-goal (highest): satisfy come/follow command
  - defend: ≤4m attack, ≤12m + low HP/many hostiles flee
  - eat: food < 16 + 5s cooldown
  - sleep: night + safe + 30s retry cooldown
  - idle: heartbeat every 20th tick
Reflex returns "skipped" when ctx.busy so we don't count busy ticks as
either productive or noop in the escalation counter.

runtime/bot.js:
  - ctx.dispatch fire-and-forget wrapper with busy gate, onComplete hook
  - consecutiveNoops counter; after ESCALATE_AFTER_NOOPS (=20, ~1 min at
    tick=3s), askPi with the current snapshot. 10-min cooldown.
  - operator chat handler: parses `<botname> <verb>` messages from
    OPERATOR_USERNAMES. Verbs: status, pause, resume, stop, come.
  - Death drops any pending operator goal.

Smoke-tested live against play.xmatic.team:25565: bot connected, logged
in via AuthMe, reflex chain dispatched flee/sleep, hard timeout fired
when pathfinder couldn't reach the flee target (expected — no usable
ground path in dark_forest at this spawn).

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
This commit is contained in:
mayatnikov
2026-05-25 16:11:17 +03:00
co-authored by Claude Opus 4.7
parent 1e3b36a9a1
commit fc5d188213
3 changed files with 576 additions and 25 deletions
Download Patch File Download Diff File Expand all files Collapse all files
runtime/bot.js
+203 -5
View File
@@ -2,7 +2,8 @@
// - the MC TCP connection + reconnect policy
// - the reflex tick loop (no LLM in hot path)
// - the IPC server for TUI clients
// - on-demand Pi-headless escalation
// - on-demand Pi-headless escalation (manual or automatic)
// - simple operator-chat commands from OPERATOR_USERNAMES
//
// Lifecycle: started by `npm run bot`. Connects to MC, spawns IPC server,
// ticks every TICK_INTERVAL_SECONDS, broadcasts STATUS to clients each tick.
@@ -23,6 +24,12 @@ import { COMMAND_TYPES, EVENT_TYPES } from "./ipc-protocol.js";
fs.mkdirSync(stateDir, { recursive: true });
const JOINED_FLAG = path.join(stateDir, "joined-before.flag");
// Auto-escalation tunables. With tick=3s, 20 noops ≈ 1 minute idle before we
// even consider asking Pi. Cooldown prevents spamming the LLM when the bot
// is permanently stuck on the same situation.
const ESCALATE_AFTER_NOOPS = 20;
const ESCALATION_COOLDOWN_MS = 10 * 60 * 1000;
let bot = null;
let reflexPaused = false;
let tickTimer = null;
@@ -30,13 +37,32 @@ let reconnectTimer = null;
let shuttingDown = false;
let lastSnapshot = { connected: false };
const reflexCtx = { snapshot: lastSnapshot, idleCounter: 0 };
let consecutiveNoops = 0;
let lastEscalationAt = 0;
// Reflex context — passed into reflex.js every tick. Mutable across ticks.
const reflexCtx = {
bot: null,
snapshot: lastSnapshot,
busy: false,
currentActionLabel: null,
operatorGoal: null,
idleCounter: 0,
lastEatAt: 0,
lastSleepAttemptAt: 0,
dispatch: dispatchAction,
clearOperatorGoal: () => {
reflexCtx.operatorGoal = null;
},
};
let chatTimestamps = [];
const CHAT_WINDOW_MS = 60_000;
let ipc;
// ---- chat rate limit -------------------------------------------------------
function chatRateAllowed() {
const now = Date.now();
chatTimestamps = chatTimestamps.filter((t) => now - t < CHAT_WINDOW_MS);
@@ -45,6 +71,17 @@ function chatRateAllowed() {
return true;
}
function botChat(text) {
if (!bot) return;
if (!chatRateAllowed()) {
warn("chat", `dropped chat (rate-limited): ${text.slice(0, 60)}`);
return;
}
bot.chat(text);
}
// ---- auth ------------------------------------------------------------------
function hasJoinedBefore() {
return fs.existsSync(JOINED_FLAG);
}
@@ -75,6 +112,107 @@ function maybeHandleAuthPrompt(text) {
markJoinedBefore();
}
// ---- action dispatch -------------------------------------------------------
// Reflexes call this to fire an async action without blocking the tick.
// Sets busy=true, runs fn, clears busy when done; optional onComplete callback
// receives the action's { ok, detail } result.
function dispatchAction(fn, label, opts = {}) {
if (reflexCtx.busy) {
warn("dispatch", `tried to dispatch ${label} while busy with ${reflexCtx.currentActionLabel}`);
return;
}
reflexCtx.busy = true;
reflexCtx.currentActionLabel = label;
info("dispatch", `→ ${label}`);
Promise.resolve()
.then(() => fn())
.then((res) => {
info("dispatch", `← ${label} ${res?.ok ? "ok" : "fail"}${res?.detail ? ` (${JSON.stringify(res.detail).slice(0, 80)})` : ""}`);
if (opts.onComplete) {
try {
opts.onComplete(res ?? { ok: false, detail: "no result" });
} catch (e) {
warn("dispatch", `onComplete threw for ${label}: ${e.message}`);
}
}
})
.catch((e) => {
warn("dispatch", `${label} threw: ${e?.message ?? e}`);
})
.finally(() => {
reflexCtx.busy = false;
reflexCtx.currentActionLabel = null;
});
}
// ---- operator chat commands ------------------------------------------------
function isOperator(username) {
if (!username) return false;
return config.operators.includes(username.toLowerCase());
}
function handleOperatorChat(username, text) {
// Two address formats accepted: prefix "<botname>," or "<botname>:" (case-insensitive),
// or full chat starting with the bot's own name. We're permissive here.
const lower = text.trim().toLowerCase();
const botname = bot.username.toLowerCase();
const prefixed = lower.startsWith(botname + " ") || lower.startsWith(botname + ",") || lower.startsWith(botname + ":");
const stripped = prefixed ? text.trim().slice(botname.length).replace(/^[,:\s]+/, "") : text.trim();
const cmd = stripped.toLowerCase();
// Unaddressed chat is fine — just don't treat it as a command.
if (!prefixed) return;
info("operator", `${username} → "${cmd}"`);
if (cmd === "status" || cmd === "how are you?") {
const s = lastSnapshot;
botChat(
`hp=${s.health}/20 food=${s.food}/20 pos=${s.position?.x},${s.position?.y},${s.position?.z}${
s.hostileCount ? ` hostiles=${s.hostileCount}` : ""
}${reflexCtx.busy ? ` busy=${reflexCtx.currentActionLabel}` : ""}`,
);
return;
}
if (cmd === "pause") {
reflexPaused = true;
botChat(`reflex paused, awaiting your call.`);
return;
}
if (cmd === "resume") {
reflexPaused = false;
botChat(`reflex resumed.`);
return;
}
if (cmd === "stop") {
botChat(`bye.`);
setTimeout(() => gracefulExit(0), 500);
return;
}
if (cmd === "come" || cmd === "come here") {
const op = Object.values(bot.entities).find((e) => e.username === username);
if (!op) {
botChat(`${username}: can't see you nearby.`);
return;
}
reflexCtx.operatorGoal = {
kind: "come",
from: username,
x: Math.round(op.position.x),
y: Math.round(op.position.y),
z: Math.round(op.position.z),
};
botChat(`on my way to ${reflexCtx.operatorGoal.x},${reflexCtx.operatorGoal.y},${reflexCtx.operatorGoal.z}`);
return;
}
botChat(`${username}: didn't recognize "${cmd}". I know: status, come, pause, resume, stop.`);
}
// ---- connect ---------------------------------------------------------------
function connect() {
if (bot) return;
info("mc", `connecting as ${config.username} → ${config.host}:${config.port} (v${config.version})`);
@@ -86,13 +224,14 @@ function connect() {
version: config.version,
hideErrors: false,
});
reflexCtx.bot = bot;
bot.once("spawn", () => {
info("mc", `spawned at ${JSON.stringify(bot.entity.position)}`);
ipc?.broadcast(EVENT_TYPES.STATUS, buildSnapshot(bot));
});
bot.on("messagestr", (text, _position, _jsonMsg) => {
bot.on("messagestr", (text) => {
ipc?.broadcast(EVENT_TYPES.CHAT, { from: "server", text, kind: "system" });
maybeHandleAuthPrompt(text);
});
@@ -100,12 +239,21 @@ function connect() {
bot.on("chat", (username, message) => {
if (username === bot.username) return;
ipc?.broadcast(EVENT_TYPES.CHAT, { from: username, text: message, kind: "player" });
if (isOperator(username)) {
try {
handleOperatorChat(username, message);
} catch (e) {
warn("operator", `handler threw: ${e.message}`);
}
}
});
bot.on("death", () => {
const pos = bot.entity?.position;
warn("mc", `died at ${JSON.stringify(pos)}`);
ipc?.broadcast(EVENT_TYPES.DEATH, { reason: "unknown", position: pos });
// On death, drop any operator goal — they need to ask again.
reflexCtx.operatorGoal = null;
});
bot.on("kicked", (reason) => {
@@ -119,6 +267,7 @@ function connect() {
bot.on("end", (reason) => {
warn("mc", `connection ended: ${reason}`);
bot = null;
reflexCtx.bot = null;
lastSnapshot = { connected: false };
if (!shuttingDown) scheduleReconnect();
});
@@ -134,13 +283,59 @@ function scheduleReconnect() {
}, delay);
}
// ---- escalation ------------------------------------------------------------
function maybeAutoEscalate() {
if (reflexCtx.busy) return;
if (consecutiveNoops < ESCALATE_AFTER_NOOPS) return;
const since = Date.now() - lastEscalationAt;
if (since < ESCALATION_COOLDOWN_MS) return;
lastEscalationAt = Date.now();
consecutiveNoops = 0;
const promptCtx = JSON.stringify(lastSnapshot, null, 2);
const prompt = [
`You are the escalation cortex for an autonomous Minecraft bot. The bot's`,
`script-driven reflex loop has produced no useful action for ${ESCALATE_AFTER_NOOPS} consecutive ticks`,
`(~${Math.round((ESCALATE_AFTER_NOOPS * config.tickIntervalMs) / 1000)}s). The reflex chain is:`,
` operator-goal > defend > eat > sleep > idle`,
`Snapshot:`,
"```json",
promptCtx,
"```",
`Decide ONE next thing the bot should attempt. Output as plain text — what it should do and why, in 3 lines max.`,
`If "do nothing" is the right answer, say so.`,
`Do NOT propose code changes. Do NOT propose anything beyond what mineflayer + the existing actions (attack, flee, eat, sleep, goTo) can do.`,
].join("\n");
info("escalation", `firing askPi after ${ESCALATE_AFTER_NOOPS} noops`);
askPi({
prompt,
onChunk: (chunk) => ipc?.broadcast(EVENT_TYPES.ASK_PI_CHUNK, chunk),
onDone: (result) => {
info("escalation", `pi done code=${result.code} dur=${result.durationMs}ms`);
ipc?.broadcast(EVENT_TYPES.ASK_PI_DONE, result);
},
});
}
// ---- tick ------------------------------------------------------------------
function tick() {
if (shuttingDown) return;
if (bot && bot.entity) {
lastSnapshot = buildSnapshot(bot);
reflexCtx.snapshot = lastSnapshot;
if (!reflexPaused) {
runTick(reflexCtx);
const result = runTick(reflexCtx);
if (!result || result.action === "noop") {
consecutiveNoops++;
maybeAutoEscalate();
} else if (result.action === "skipped") {
// busy — neither productive nor stuck; don't increment noops
} else {
consecutiveNoops = 0;
}
}
ipc?.broadcast(EVENT_TYPES.STATUS, lastSnapshot);
} else {
@@ -154,12 +349,13 @@ function startTickLoop() {
tickTimer = setInterval(tick, config.tickIntervalMs);
}
// ---- IPC commands ----------------------------------------------------------
function handleCommand(msg, send) {
switch (msg.type) {
case COMMAND_TYPES.PAUSE:
reflexPaused = true;
info("ipc", "reflex paused by client");
send(EVENT_TYPES.LOG, { ts: new Date().toISOString(), level: "info", source: "ipc", text: "reflex paused" });
break;
case COMMAND_TYPES.RESUME:
reflexPaused = false;
@@ -197,6 +393,8 @@ function handleCommand(msg, send) {
}
}
// ---- shutdown --------------------------------------------------------------
function gracefulExit(code) {
if (shuttingDown) return;
shuttingDown = true;