openclaw-plugin-grinders-farm 0.3.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Grinder's Farm contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,64 @@
+# openclaw-plugin-grinders-farm
+
+OpenClaw plugin for Grinder's Farm. Registers:
+
+- `/farm` command
+- `grinders_farm` tool (for skill `command-dispatch: tool`)
+
+## Install (End User)
+
+```bash
+openclaw plugins install openclaw-plugin-grinders-farm --dangerously-force-unsafe-install
+```
+
+No local repo clone or build is required for end users.
+
+## Runtime Resolution
+
+The plugin tries these options in order:
+
+1. `GRINDERS_FARM_ROOT` env
+2. plugin config `gameRoot`
+3. parent directory of this plugin
+4. `grinders-farm` CLI in `PATH` (or `GRINDERS_FARM_CLI_BIN`)
+
+If `gameRoot` is available, plugin can auto-start:
+
+- local image server (`imageServerPort`)
+- local auto worker (fixed 20s/day)
+
+If only CLI mode is available, plugin still works and can auto-run `grinders-farm start`.
+
+## Minimal OpenClaw Config
+
+```json
+{
+  "plugins": {
+    "entries": {
+      "grinders-farm": {
+        "enabled": true,
+        "source": "openclaw-plugin-grinders-farm",
+        "config": {
+          "autoStartWorkerOnGatewayBoot": true
+        }
+      }
+    }
+  }
+}
+```
+
+Optional if auto-detection fails:
+
+```json
+{
+  "plugins": {
+    "entries": {
+      "grinders-farm": {
+        "config": {
+          "gameRoot": "/path/to/grinders-farm"
+        }
+      }
+    }
+  }
+}
+```

package/dist/delivery.js

@@ -0,0 +1,140 @@
+/**
+ * 仅放在 openclaw-plugin/ 内，不 import 仓库 ../src。
+ * 安装到 ~/.openclaw/extensions/grinders-farm 时也能工作。
+ */
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+export const OPENCLAW_DELIVERY_PATH = path.join(os.homedir(), ".grinders-farm", "openclaw-delivery.json");
+export const OPENCLAW_DELIVERIES_PATH = path.join(os.homedir(), ".grinders-farm", "openclaw-deliveries.json");
+function persistOpenclawDelivery(payload) {
+    fs.mkdirSync(path.dirname(OPENCLAW_DELIVERY_PATH), { recursive: true });
+    fs.writeFileSync(OPENCLAW_DELIVERY_PATH, JSON.stringify(payload, null, 2), "utf8");
+    persistOpenclawDeliveryList(payload);
+}
+function loadOpenclawDeliveryList() {
+    if (!fs.existsSync(OPENCLAW_DELIVERIES_PATH))
+        return [];
+    try {
+        const raw = JSON.parse(fs.readFileSync(OPENCLAW_DELIVERIES_PATH, "utf8"));
+        if (!Array.isArray(raw))
+            return [];
+        return raw
+            .map((entry) => {
+            if (!entry || typeof entry !== "object")
+                return null;
+            const r = entry;
+            const channel = typeof r.channel === "string" ? r.channel.trim() : "";
+            const target = typeof r.target === "string" ? r.target.trim() : "";
+            if (!channel || !target)
+                return null;
+            return {
+                channel,
+                target,
+                ...(typeof r.accountId === "string" && r.accountId.trim() ? { accountId: r.accountId.trim() } : {}),
+                ...(r.threadId != null ? { threadId: r.threadId } : {}),
+                ...(typeof r.sessionKey === "string" && r.sessionKey.trim() ? { sessionKey: r.sessionKey.trim() } : {}),
+            };
+        })
+            .filter((entry) => entry != null);
+    }
+    catch {
+        return [];
+    }
+}
+function deliveryKey(entry) {
+    const channel = entry.channel.trim().toLowerCase();
+    const account = entry.accountId?.trim() ?? "";
+    const target = entry.target.trim();
+    const thread = entry.threadId == null ? "" : String(entry.threadId);
+    const session = entry.sessionKey?.trim() ?? "";
+    return [channel, account, target, thread, session].join("|");
+}
+function persistOpenclawDeliveryList(payload) {
+    const current = loadOpenclawDeliveryList();
+    const key = deliveryKey(payload);
+    const deduped = current.filter((entry) => deliveryKey(entry) !== key);
+    deduped.push(payload);
+    fs.writeFileSync(OPENCLAW_DELIVERIES_PATH, JSON.stringify(deduped, null, 2), "utf8");
+}
+/**
+ * 从插件命令 ctx 写入投递。优先 to/from；若缺失则用 senderId（Web 控制端等常有 senderId 无 to/from）。
+ * channel 优先 ctx.channel，否则 ctx.channelId。
+ */
+export function saveOpenclawDeliveryFromBridge(ctx) {
+    const channel = (ctx.channel ?? ctx.channelId)?.toString().trim();
+    const target = (ctx.to ?? ctx.from ?? ctx.senderId)?.toString().trim();
+    if (!channel || !target)
+        return false;
+    persistOpenclawDelivery({
+        channel,
+        target,
+        ...(ctx.accountId?.trim() ? { accountId: ctx.accountId.trim() } : {}),
+        ...(ctx.messageThreadId != null ? { threadId: ctx.messageThreadId } : {}),
+    });
+    return true;
+}
+/**
+ * 先 sync 保存；失败时再试 OpenClaw 的会话绑定（部分界面 to/from 为空但绑定里有 conversationId）。
+ */
+export async function bindDeliveryFromPluginCommand(ctx) {
+    if (saveOpenclawDeliveryFromBridge(ctx))
+        return true;
+    if (typeof ctx.getCurrentConversationBinding !== "function")
+        return false;
+    try {
+        const b = await ctx.getCurrentConversationBinding();
+        if (!b?.channel?.trim() || !b.conversationId?.trim())
+            return false;
+        persistOpenclawDelivery({
+            channel: b.channel.trim(),
+            target: b.conversationId.trim(),
+            accountId: b.accountId?.trim(),
+            threadId: b.threadId,
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function trySaveOpenclawDeliveryFromInboundClaim(event) {
+    const target = event.conversationId?.trim() || event.senderId?.trim();
+    const channel = event.channel?.trim();
+    if (!target || !channel)
+        return false;
+    const payload = {
+        channel,
+        target,
+        ...(event.accountId?.trim() ? { accountId: event.accountId.trim() } : {}),
+        ...(event.threadId != null ? { threadId: event.threadId } : {}),
+    };
+    if (!fs.existsSync(OPENCLAW_DELIVERY_PATH)) {
+        fs.mkdirSync(path.dirname(OPENCLAW_DELIVERY_PATH), { recursive: true });
+        fs.writeFileSync(OPENCLAW_DELIVERY_PATH, JSON.stringify(payload, null, 2), "utf8");
+        persistOpenclawDeliveryList(payload);
+        return true;
+    }
+    persistOpenclawDeliveryList(payload);
+    return true;
+}
+/** message_received 备用：部分通道 inbound_claim 字段不全 */
+export function trySaveOpenclawDeliveryFromMessageHook(event, ctx) {
+    const target = ctx.conversationId?.trim() || event.from?.trim();
+    const channel = ctx.channelId?.trim();
+    if (!target || !channel)
+        return false;
+    const payload = {
+        channel,
+        target,
+        ...(ctx.accountId?.trim() ? { accountId: ctx.accountId.trim() } : {}),
+    };
+    if (!fs.existsSync(OPENCLAW_DELIVERY_PATH)) {
+        fs.mkdirSync(path.dirname(OPENCLAW_DELIVERY_PATH), { recursive: true });
+        fs.writeFileSync(OPENCLAW_DELIVERY_PATH, JSON.stringify(payload, null, 2), "utf8");
+        persistOpenclawDeliveryList(payload);
+        return true;
+    }
+    persistOpenclawDeliveryList(payload);
+    return true;
+}

package/dist/index.js

@@ -0,0 +1,354 @@
+import { spawnSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { OPENCLAW_DELIVERY_PATH, bindDeliveryFromPluginCommand, trySaveOpenclawDeliveryFromInboundClaim, trySaveOpenclawDeliveryFromMessageHook, } from "./delivery.js";
+import { startImageServerAtRoot } from "./start-image-server.js";
+import { startLocalAutoAtRoot } from "./start-local-auto.js";
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const FARM_IMAGE_PATH = path.join(os.homedir(), ".grinders-farm", "farm.png");
+const OPENCLAW_MEDIA_DIR = path.join(os.homedir(), ".openclaw", "media", "grinders-farm");
+const ONESHOT_RELATIVE_PATH = path.join("src", "adapters", "oneshot.ts");
+const DEFAULT_START_INTERVAL_SEC = 20;
+function resolveGameRoot(api) {
+    const raw = api.pluginConfig;
+    const fromEnv = process.env.GRINDERS_FARM_ROOT?.trim();
+    if (fromEnv)
+        return path.resolve(fromEnv);
+    if (raw?.gameRoot?.trim())
+        return path.resolve(raw.gameRoot.trim());
+    return path.resolve(__dirname, "..");
+}
+function isValidGameRoot(candidate) {
+    return fs.existsSync(path.join(candidate, ONESHOT_RELATIVE_PATH));
+}
+function resolveClawFarmCliBin() {
+    const fromEnv = process.env.GRINDERS_FARM_CLI_BIN?.trim();
+    if (fromEnv)
+        return fromEnv;
+    try {
+        const which = spawnSync("sh", ["-lc", "command -v grinders-farm"], {
+            encoding: "utf8",
+            maxBuffer: 1024 * 1024,
+        });
+        const out = (which.stdout ?? "").trim();
+        if (out)
+            return out;
+    }
+    catch {
+        // ignore
+    }
+    return null;
+}
+function resolveRuntimeMode(api) {
+    const gameRoot = resolveGameRoot(api);
+    if (isValidGameRoot(gameRoot)) {
+        return { kind: "repo-tsx", gameRoot };
+    }
+    const bin = resolveClawFarmCliBin();
+    if (bin) {
+        return { kind: "cli-bin", bin };
+    }
+    return null;
+}
+function getPluginTiming(api) {
+    const c = api.pluginConfig;
+    const autoBoot = c?.autoStartWorkerOnGatewayBoot !== false;
+    const imageServerPort = typeof c?.imageServerPort === "number" && c.imageServerPort >= 1 ? c.imageServerPort : 18931;
+    return { autoBoot, imageServerPort };
+}
+function runOneshot(mode, argsLine) {
+    const argv = argsLine.trim().length > 0 ? argsLine.trim().split(/\s+/) : ["farm"];
+    const resolvedOpenclawBin = resolveOpenclawBin();
+    const result = mode.kind === "repo-tsx"
+        ? spawnSync("npx", ["tsx", path.join(mode.gameRoot, ONESHOT_RELATIVE_PATH), ...argv], {
+            cwd: mode.gameRoot,
+            encoding: "utf8",
+            maxBuffer: 8 * 1024 * 1024,
+            env: {
+                ...process.env,
+                OPENCLAW_BIN: process.env.OPENCLAW_BIN?.trim() || resolvedOpenclawBin,
+            },
+        })
+        : spawnSync(mode.bin, argv, {
+            encoding: "utf8",
+            maxBuffer: 8 * 1024 * 1024,
+            env: {
+                ...process.env,
+                OPENCLAW_BIN: process.env.OPENCLAW_BIN?.trim() || resolvedOpenclawBin,
+            },
+        });
+    const stderr = result.stderr?.trim() ?? "";
+    const stdout = result.stdout?.trim() ?? "";
+    const combined = [stdout, stderr].filter(Boolean).join("\n");
+    const code = result.status ?? (result.error ? 1 : 0);
+    return { text: combined || (result.error ? String(result.error.message) : "(no output)"), exitCode: code };
+}
+function isTelegramChannel(ctx) {
+    const surface = (ctx.channel ?? ctx.channelId ?? "").toString().trim().toLowerCase();
+    return surface === "tg" || surface.includes("telegram");
+}
+function canAttachFarmImage() {
+    return fs.existsSync(FARM_IMAGE_PATH);
+}
+function shouldAttachFarmImageForReply(text) {
+    // Only attach image when oneshot output explicitly includes farm image link.
+    // This avoids stale farm.png being sent for text-only commands like `shop`.
+    return text.includes("🖼 查看高清像素图:");
+}
+function stageFarmImageForOpenclaw() {
+    try {
+        fs.mkdirSync(OPENCLAW_MEDIA_DIR, { recursive: true });
+        const staged = path.join(OPENCLAW_MEDIA_DIR, `farm-${Date.now()}.png`);
+        fs.copyFileSync(FARM_IMAGE_PATH, staged);
+        return staged;
+    }
+    catch {
+        return null;
+    }
+}
+function resolveOpenclawBin() {
+    const fromEnv = process.env.OPENCLAW_BIN?.trim();
+    if (fromEnv && fromEnv.length > 0)
+        return fromEnv;
+    try {
+        const which = spawnSync("sh", ["-lc", "command -v openclaw"], {
+            encoding: "utf8",
+            maxBuffer: 1024 * 1024,
+        });
+        const fromWhich = (which.stdout ?? "").trim();
+        if (fromWhich)
+            return fromWhich;
+    }
+    catch {
+        // keep trying
+    }
+    const candidates = [
+        process.env.OPENCLAW_PATH?.trim(),
+        process.env.NVM_BIN ? path.join(process.env.NVM_BIN, "openclaw") : "",
+        path.join(path.dirname(process.execPath), "openclaw"),
+        "/opt/homebrew/bin/openclaw",
+        "/usr/local/bin/openclaw",
+    ]
+        .map((p) => (p ?? "").trim())
+        .filter(Boolean);
+    for (const p of candidates) {
+        try {
+            fs.accessSync(p, fs.constants.X_OK);
+            return p;
+        }
+        catch {
+            // keep trying
+        }
+    }
+    return "openclaw";
+}
+function resolveDeliveryFallback() {
+    try {
+        if (!fs.existsSync(OPENCLAW_DELIVERY_PATH))
+            return {};
+        const raw = JSON.parse(fs.readFileSync(OPENCLAW_DELIVERY_PATH, "utf8"));
+        const target = typeof raw.target === "string" ? raw.target.trim() : "";
+        const accountId = typeof raw.accountId === "string" ? raw.accountId.trim() : "";
+        const channel = typeof raw.channel === "string" ? raw.channel.trim() : "";
+        const threadId = typeof raw.threadId === "string" || typeof raw.threadId === "number" ? raw.threadId : undefined;
+        return {
+            ...(target ? { target } : {}),
+            ...(accountId ? { accountId } : {}),
+            ...(channel ? { channel } : {}),
+            ...(threadId != null ? { threadId } : {}),
+        };
+    }
+    catch {
+        return {};
+    }
+}
+function buildTelegramImageCaption(text) {
+    const lines = text
+        .split("\n")
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0);
+    const nonTableLines = lines.filter((line) => !line.startsWith("|"));
+    const title = nonTableLines[0] ?? "🌾 Grinder's Farm";
+    const orderDoneLine = nonTableLines.find((line) => line.startsWith("✅ 完成订单："));
+    const orderLine = nonTableLines.find((line) => line.startsWith("📦 订单:"));
+    const marketLine = nonTableLines.find((line) => line.startsWith("📉 市场反馈："));
+    const parts = [title, orderDoneLine, orderLine, marketLine].filter(Boolean);
+    return parts.join("\n");
+}
+function trySendTelegramFarmImage(api, ctx, caption) {
+    const fallback = resolveDeliveryFallback();
+    const target = (ctx.to ?? ctx.from ?? ctx.senderId ?? fallback.target)?.toString().trim();
+    if (!target) {
+        api.logger?.warn?.("grinders-farm: skip telegram image send: missing target.");
+        return false;
+    }
+    if (!canAttachFarmImage()) {
+        api.logger?.warn?.(`grinders-farm: skip telegram image send: image not found (${FARM_IMAGE_PATH}).`);
+        return false;
+    }
+    const stagedImagePath = stageFarmImageForOpenclaw();
+    if (!stagedImagePath) {
+        api.logger?.warn?.("grinders-farm: skip telegram image send: failed to stage image into ~/.openclaw/media.");
+        return false;
+    }
+    const args = ["message", "send", "--channel", "telegram", "--target", target, "--message", caption];
+    const accountId = ctx.accountId?.trim() || fallback.accountId;
+    if (accountId)
+        args.push("--account", accountId);
+    const threadId = ctx.messageThreadId ?? fallback.threadId;
+    if (threadId != null)
+        args.push("--thread-id", String(threadId));
+    args.push("--media", stagedImagePath);
+    const r = spawnSync(resolveOpenclawBin(), args, {
+        encoding: "utf8",
+        maxBuffer: 8 * 1024 * 1024,
+        env: { ...process.env },
+    });
+    if (r.error) {
+        api.logger?.warn?.(`grinders-farm: telegram image send error: ${String(r.error.message)}`);
+        return false;
+    }
+    const code = r.status ?? 0;
+    if (code !== 0) {
+        const details = [r.stdout, r.stderr].filter(Boolean).join("\n").trim();
+        api.logger?.warn?.(`grinders-farm: telegram image send failed (exit ${code}) ${details || "(no output)"}`);
+        return false;
+    }
+    return true;
+}
+function createFarmTool(mode) {
+    return {
+        name: "grinders_farm",
+        label: "Grinder's Farm",
+        ownerOnly: false,
+        description: "Run grinders-farm one-shot CLI. Used by SKILL command-dispatch; params include `command` (raw args after /grinders_farm).",
+        parameters: {
+            type: "object",
+            additionalProperties: true,
+            properties: {
+                command: { type: "string", description: "Raw args after /grinders_farm, e.g. plant carrot A1" },
+                commandName: { type: "string" },
+                skillName: { type: "string" },
+            },
+        },
+        execute: async (_toolCallId, params) => {
+            const raw = typeof params.command === "string" ? params.command : "";
+            const { text, exitCode } = runOneshot(mode, raw);
+            return {
+                content: [{ type: "text", text }],
+                details: { exitCode },
+                isError: exitCode !== 0,
+            };
+        },
+    };
+}
+const plugin = {
+    id: "grinders-farm",
+    name: "Grinder's Farm",
+    description: "Local grinders-farm subprocess only; no LLM in the game path.",
+    register(api) {
+        const runtime = resolveRuntimeMode(api);
+        if (!runtime) {
+            api.logger?.error?.("grinders-farm: 无法定位运行时。请任选其一：1) 在插件 config 里设置 gameRoot（含 src/adapters/oneshot.ts）；2) 安装 grinders-farm CLI 并加入 PATH；3) 设置 GRINDERS_FARM_ROOT / GRINDERS_FARM_CLI_BIN。");
+            return;
+        }
+        api.registerTool(createFarmTool(runtime));
+        api.registerCommand({
+            name: "farm",
+            description: "Grinder's Farm — run a game command without invoking the model (fast path). Binds this chat for farm push.",
+            acceptsArgs: true,
+            handler: async (ctx) => {
+                const bound = await bindDeliveryFromPluginCommand(ctx);
+                if (!bound) {
+                    api.logger?.warn?.("grinders-farm: could not bind delivery (need channel + senderId/to/from, or conversation binding).");
+                }
+                else {
+                    const surface = (ctx.channel ?? ctx.channelId)?.toString().toLowerCase() ?? "";
+                    if (surface === "webchat") {
+                        api.logger?.info?.("grinders-farm: Web 控制端已绑定；自动推送使用 Gateway chat.inject（默认会话 agent:<agentId>:main）。");
+                    }
+                }
+                const { text, exitCode } = runOneshot(runtime, ctx.args ?? "");
+                const fallback = resolveDeliveryFallback();
+                const telegramLikeChannel = isTelegramChannel(ctx) || (fallback.channel?.toLowerCase().includes("telegram") ?? false);
+                if (exitCode === 0 && telegramLikeChannel && shouldAttachFarmImageForReply(text) && canAttachFarmImage()) {
+                    const stagedImagePath = stageFarmImageForOpenclaw();
+                    if (stagedImagePath) {
+                        // Prefer native command reply media to avoid fallback-to-table behavior
+                        // in newer OpenClaw versions when command replies are text-only.
+                        return {
+                            text: buildTelegramImageCaption(text),
+                            mediaUrls: [stagedImagePath],
+                            isError: false,
+                        };
+                    }
+                    api.logger?.warn?.("grinders-farm: skip telegram inline media reply: failed to stage image.");
+                }
+                return { text, isError: exitCode !== 0 };
+            },
+        });
+        api.on("gateway_start", async () => {
+            const { autoBoot, imageServerPort } = getPluginTiming(api);
+            if (runtime.kind !== "repo-tsx") {
+                if (!autoBoot)
+                    return;
+                const autoStart = runOneshot(runtime, "start");
+                if (autoStart.exitCode === 0) {
+                    api.logger?.info?.("grinders-farm: 已通过 CLI 模式启动自动推进（固定 20s）");
+                }
+                else {
+                    api.logger?.warn?.(`grinders-farm: CLI 模式自动推进启动失败：${autoStart.text}`);
+                }
+                return;
+            }
+            try {
+                const imageServer = await startImageServerAtRoot(runtime.gameRoot, imageServerPort);
+                if (imageServer.success) {
+                    api.logger?.info?.(`grinders-farm: ${imageServer.message}`);
+                }
+                else {
+                    api.logger?.warn?.(`grinders-farm: gateway_start image-server: ${imageServer.message}`);
+                }
+            }
+            catch (e) {
+                api.logger?.warn?.(`grinders-farm: gateway_start image-server: ${String(e)}`);
+            }
+            if (!autoBoot)
+                return;
+            try {
+                const r = await startLocalAutoAtRoot(runtime.gameRoot, DEFAULT_START_INTERVAL_SEC);
+                if (r.success) {
+                    api.logger?.info?.(`grinders-farm: ${r.message}`);
+                }
+                else {
+                    api.logger?.warn?.(`grinders-farm: gateway_start worker: ${r.message}`);
+                }
+            }
+            catch (e) {
+                api.logger?.warn?.(`grinders-farm: gateway_start: ${String(e)}`);
+            }
+        });
+        api.on("inbound_claim", async (event, ctx) => {
+            const saved = trySaveOpenclawDeliveryFromInboundClaim({
+                channel: event.channel,
+                accountId: event.accountId ?? ctx.accountId,
+                conversationId: event.conversationId ?? ctx.conversationId,
+                senderId: event.senderId ?? ctx.senderId,
+                threadId: event.threadId,
+            });
+            if (saved) {
+                api.logger?.info?.("grinders-farm: wrote openclaw-delivery.json (inbound_claim)");
+            }
+            return { handled: false };
+        });
+        api.on("message_received", async (event, ctx) => {
+            const saved = trySaveOpenclawDeliveryFromMessageHook(event, ctx);
+            if (saved) {
+                api.logger?.info?.("grinders-farm: wrote openclaw-delivery.json (message_received)");
+            }
+        });
+    },
+};
+export default plugin;

package/dist/start-image-server.js

@@ -0,0 +1,81 @@
+import { spawn } from "node:child_process";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+const DATA_DIR = path.join(os.homedir(), ".grinders-farm");
+const PID_FILE = path.join(DATA_DIR, "image-server.pid");
+const INFO_FILE = path.join(DATA_DIR, "image-server.json");
+function isProcessRunning(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function removeStalePidFile() {
+    if (!fs.existsSync(PID_FILE))
+        return;
+    const raw = fs.readFileSync(PID_FILE, "utf8").trim();
+    const pid = Number.parseInt(raw, 10);
+    if (!Number.isFinite(pid) || !isProcessRunning(pid)) {
+        try {
+            fs.unlinkSync(PID_FILE);
+        }
+        catch {
+            /* ignore */
+        }
+        try {
+            if (fs.existsSync(INFO_FILE))
+                fs.unlinkSync(INFO_FILE);
+        }
+        catch {
+            /* ignore */
+        }
+    }
+}
+function tryGetBaseUrlFromInfoFile() {
+    if (!fs.existsSync(INFO_FILE))
+        return null;
+    try {
+        const raw = JSON.parse(fs.readFileSync(INFO_FILE, "utf8"));
+        return typeof raw.baseUrl === "string" && raw.baseUrl.trim() ? raw.baseUrl.trim() : null;
+    }
+    catch {
+        return null;
+    }
+}
+export async function startImageServerAtRoot(gameRoot, preferredPort) {
+    removeStalePidFile();
+    if (fs.existsSync(PID_FILE)) {
+        const pid = Number.parseInt(fs.readFileSync(PID_FILE, "utf8").trim(), 10);
+        if (Number.isFinite(pid) && isProcessRunning(pid)) {
+            const baseUrl = tryGetBaseUrlFromInfoFile();
+            return { success: true, message: `本地图片服务已在运行 (PID ${pid})${baseUrl ? ` · ${baseUrl}` : ""}` };
+        }
+    }
+    const worker = path.join(gameRoot, "src/adapters/image-server.ts");
+    const port = Number.isFinite(preferredPort) && preferredPort > 0 ? preferredPort : 18931;
+    const child = spawn("npx", ["tsx", worker, String(port)], {
+        cwd: gameRoot,
+        detached: true,
+        stdio: "ignore",
+    });
+    child.unref();
+    for (let i = 0; i < 60; i++) {
+        await new Promise((resolve) => setTimeout(resolve, 50));
+        if (fs.existsSync(INFO_FILE)) {
+            const pid = fs.existsSync(PID_FILE) ? fs.readFileSync(PID_FILE, "utf8").trim() : "?";
+            const baseUrl = tryGetBaseUrlFromInfoFile();
+            return {
+                success: true,
+                message: `本地图片服务已启动 (PID ${pid})${baseUrl ? ` · ${baseUrl}` : ""}`,
+            };
+        }
+    }
+    return {
+        success: false,
+        message: "本地图片服务未就绪：请确认 gameRoot 指向 grinders-farm 仓库且可运行 npx tsx src/adapters/image-server.ts",
+    };
+}

package/dist/start-local-auto.js

@@ -0,0 +1,137 @@
+/**
+ * 不 import ../src/local-auto：插件装在 extensions 时 ../src 不存在。
+ */
+import { spawn, spawnSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+const DATA_DIR = path.join(os.homedir(), ".grinders-farm");
+const AUTO_PID_FILE = path.join(DATA_DIR, "auto.pid");
+const AUTO_CONFIG_FILE = path.join(DATA_DIR, "auto.config.json");
+function isProcessRunning(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function listRunningAutoWorkerPids() {
+    try {
+        const ps = spawnSync("ps", ["-Ao", "pid,command"], {
+            encoding: "utf8",
+            maxBuffer: 4 * 1024 * 1024,
+        });
+        const out = (ps.stdout ?? "").trim();
+        if (!out)
+            return [];
+        const pids = new Set();
+        for (const line of out.split("\n")) {
+            if (!line.includes("src/adapters/auto-worker.ts"))
+                continue;
+            const m = line.trim().match(/^(\d+)\s+/);
+            if (!m)
+                continue;
+            const pid = parseInt(m[1], 10);
+            if (!Number.isFinite(pid))
+                continue;
+            pids.add(pid);
+        }
+        return Array.from(pids.values()).sort((a, b) => a - b);
+    }
+    catch {
+        return [];
+    }
+}
+function resolveOpenclawBinForWorker() {
+    const fromEnv = process.env.OPENCLAW_BIN?.trim();
+    if (fromEnv)
+        return fromEnv;
+    const which = spawnSync("sh", ["-lc", "command -v openclaw"], {
+        encoding: "utf8",
+        maxBuffer: 1024 * 1024,
+    });
+    const fromWhich = (which.stdout ?? "").trim();
+    if (fromWhich)
+        return fromWhich;
+    const candidates = [
+        process.env.OPENCLAW_PATH?.trim(),
+        process.env.NVM_BIN ? path.join(process.env.NVM_BIN, "openclaw") : "",
+        "/opt/homebrew/bin/openclaw",
+        "/usr/local/bin/openclaw",
+    ]
+        .map((p) => (p ?? "").trim())
+        .filter(Boolean);
+    for (const p of candidates) {
+        try {
+            fs.accessSync(p, fs.constants.X_OK);
+            return p;
+        }
+        catch {
+            // keep trying
+        }
+    }
+    return null;
+}
+function removeStalePidFile() {
+    if (!fs.existsSync(AUTO_PID_FILE))
+        return;
+    const raw = fs.readFileSync(AUTO_PID_FILE, "utf8").trim();
+    const pid = parseInt(raw, 10);
+    if (!Number.isFinite(pid) || !isProcessRunning(pid)) {
+        try {
+            fs.unlinkSync(AUTO_PID_FILE);
+        }
+        catch {
+            /* ignore */
+        }
+        try {
+            if (fs.existsSync(AUTO_CONFIG_FILE))
+                fs.unlinkSync(AUTO_CONFIG_FILE);
+        }
+        catch {
+            /* ignore */
+        }
+    }
+}
+export async function startLocalAutoAtRoot(gameRoot, intervalSec) {
+    removeStalePidFile();
+    const runningPids = listRunningAutoWorkerPids();
+    if (runningPids.length > 0) {
+        return { success: false, message: `自动推进已在运行中 (PID ${runningPids.join(", ")})` };
+    }
+    if (fs.existsSync(AUTO_PID_FILE)) {
+        const pid = parseInt(fs.readFileSync(AUTO_PID_FILE, "utf8").trim(), 10);
+        if (Number.isFinite(pid) && isProcessRunning(pid)) {
+            return { success: false, message: `自动推进已在运行中 (PID ${pid})` };
+        }
+    }
+    const worker = path.join(gameRoot, "src/adapters/auto-worker.ts");
+    const resolvedOpenclawBin = resolveOpenclawBinForWorker();
+    const child = spawn("npx", ["tsx", worker, String(intervalSec)], {
+        cwd: gameRoot,
+        detached: true,
+        stdio: "ignore",
+        env: {
+            ...process.env,
+            ...(resolvedOpenclawBin ? { OPENCLAW_BIN: resolvedOpenclawBin } : {}),
+        },
+    });
+    child.unref();
+    for (let i = 0; i < 50; i++) {
+        await new Promise((resolve) => setTimeout(resolve, 50));
+        if (fs.existsSync(AUTO_PID_FILE)) {
+            const pid = fs.readFileSync(AUTO_PID_FILE, "utf8").trim();
+            const human = intervalSec >= 3600 ? `每 ${Math.round(intervalSec / 3600)} 小时` : `每 ${intervalSec} 秒`;
+            return {
+                success: true,
+                message: `本地 auto-worker 已启动 · ${human} · PID ${pid}`,
+            };
+        }
+    }
+    return {
+        success: false,
+        message: "auto-worker 未就绪：请确认 gameRoot 指向 grinders-farm 仓库且可运行 npx tsx src/adapters/auto-worker.ts",
+    };
+}

package/openclaw.plugin.json

@@ -0,0 +1,23 @@
+{
+  "id": "grinders-farm",
+  "name": "Grinder's Farm",
+  "description": "Local grinders-farm plugin: /farm and grinders_farm run deterministic local game logic (no LLM, no remote backend).",
+  "configSchema": {
+    "type": "object",
+    "additionalProperties": false,
+    "properties": {
+      "gameRoot": {
+        "type": "string",
+        "description": "Path to grinders-farm repo root (contains src/adapters/oneshot.ts). Optional when `grinders-farm` CLI is already in PATH or `GRINDERS_FARM_ROOT` is set."
+      },
+      "autoStartWorkerOnGatewayBoot": {
+        "type": "boolean",
+        "description": "If true (default), auto-start background day-advance worker on Gateway boot. Set false to start manually."
+      },
+      "imageServerPort": {
+        "type": "number",
+        "description": "Local HTTP image server port for farm.png links (default 18931, listens on 127.0.0.1 only)."
+      }
+    }
+  }
+}

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "openclaw-plugin-grinders-farm",
+  "version": "0.3.0",
+  "private": false,
+  "type": "module",
+  "description": "OpenClaw plugin for Grinder's Farm: deterministic /farm command and grinders_farm tool.",
+  "main": "dist/index.js",
+  "license": "MIT",
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "prepack": "npm run build"
+  },
+  "files": [
+    "dist/",
+    "openclaw.plugin.json",
+    "README.md",
+    "LICENSE"
+  ],
+  "devDependencies": {
+    "@types/node": "^24.3.0",
+    "typescript": "^5.9.2"
+  },
+  "peerDependencies": {
+    "openclaw": ">=2026.1.0"
+  },
+  "openclaw": {
+    "extensions": ["./dist/index.js"]
+  }
+}