@agentmessier/openclaw-agent-messier 0.3.1 → 0.3.3

package/index.ts

@@ -116,13 +116,16 @@ export default function register(api: OpenClawPluginApi) {
         else ctx.logger.info(`[${label}] idle — ask me to join or create a game.`);
       } catch (e) { ctx.logger.error(`[${label}] startup seating failed: ${String(e)}`); }
 
-      // Seat poller: a seat may be taken from ANOTHER process (a chat turn, the
-      // generated *_join tool, the dashboard). Poll the venue's lobby for a
-      // non-ended room that references our agentId and aim the loop at it. Driven
-      // by spec.client.lobby.route — no hardcoded /matches path. Skipped for
-      // venues with no lobby in their spec.
-      if (lobbyRoute) {
+      // Seat poller: when the agent is IDLE, a seat may be taken from ANOTHER
+      // process (a chat turn, the generated *_join tool, the dashboard). Poll the
+      // venue's lobby for a non-ended room referencing our agentId and adopt it.
+      // Driven by spec.client.lobby.route — no hardcoded /matches path. Skipped
+      // when a match is pinned (explicit room wins) or the venue has no lobby.
+      // Critically it only adopts while idle (session.matchId empty): once we're
+      // in a match it must NOT yank us into some other (e.g. stale) room.
+      if (lobbyRoute && !cfg.matchId) {
         poller = setInterval(async () => {
+          if (session.matchId) return; // already seated/playing → nothing to adopt
           try {
             const res = await fetch(`${base}${lobbyRoute}`);
             if (!res.ok) return;
@@ -130,7 +133,7 @@ export default function register(api: OpenClawPluginApi) {
             const rows = (data.matches ?? data.rows ?? []) as Record<string, any>[];
             const mine = rows.find((r) => !ENDED.has(String(r.status ?? "")) && referencesAgent(r, agentId));
             const id = mine?.id ?? mine?.[roomIdField];
-            if (id && id !== session.matchId) {
+            if (id) {
               ctx.logger.info(`[${label}] found my seat in ${id} (taken elsewhere) — starting to play`);
               await session.joinAndWatch!(id);
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentmessier/openclaw-agent-messier",
-  "version": "0.3.1",
+  "version": "0.3.3",
   "description": "Agent Messier multi-venue client for OpenClaw \u2014 play games and work tasks on the AgentNet platform (soccer today; venues discovered from the marketplace registry)",
   "type": "module",
   "license": "MIT",

package/src/generate.test.ts

@@ -17,8 +17,9 @@ const GOLF_SPEC: GameSpec = {
   client: {
     prefix: "golf", noun: "round",
     lobby: { tool: "golf_rounds", route: "/rounds", params: {}, summary: "List rounds." },
-    join: { tool: "golf_join", route: "/quickround", seatRoute: "/rounds/{matchId}/join", params: { holes: { type: "integer" } }, seat: { id: "matchId", token: "token", controls: "playerIds" }, summary: "Join a round." },
+    join: { tool: "golf_join", route: "/quickround", seatRoute: "/rounds/{matchId}/join", params: { holes: { type: "integer" }, matchId: { type: "string" } }, seat: { id: "matchId", token: "token", controls: "playerIds" }, summary: "Join a round." },
     autoplay: { tool: "golf_autoplay", summary: "Hands-free." },
+    leave: { tool: "golf_leave", route: "/rounds/{matchId}/leave", summary: "Leave the round (forfeit if live)." },
     observe: { tool: "golf_observe", params: {}, summary: "See the course." },
     act: { tool: "golf_play", params: { club: { type: "string" } }, summary: "Swing." },
   },
@@ -38,7 +39,7 @@ describe("generated tool surface comes entirely from the spec", () => {
     _resetSeats();
     const tools = generateVenueTools(GOLF_VENUE, GOLF_SPEC, cfg());
     const names = tools.map(t => t.name);
-    expect(names).toEqual(["golf_rounds", "golf_join", "golf_observe", "golf_play"]);
+    expect(names).toEqual(["golf_rounds", "golf_join", "golf_observe", "golf_play", "golf_leave"]);
 
     // The act tool is BATCH (golf seats players) and carries the spec's action enum.
     const play = tools.find(t => t.name === "golf_play")!;
@@ -86,6 +87,17 @@ describe("joinVenue — the one spec-driven seating path (tool + service share i
     expect(url).toBe("http://golf.test/rounds/r7/join");
   });
 
+  it("rejoin response without the seat-id field falls back to the matchId joined with", async () => {
+    _resetSeats();
+    // per-room join responses omit matchId (you already know it from the URL) —
+    // seat.id must still resolve, or the observe loop 404s and reclaim-loops.
+    vi.stubGlobal("fetch", vi.fn(async () =>
+      ({ ok: true, json: async () => ({ token: "t", playerIds: ["p1", "p2", "p3"], started: true }) }) as any));
+    const seat = await joinVenue(GOLF_VENUE, GOLF_SPEC, cfg(), { matchId: "r7" });
+    expect(seat.id).toBe("r7");
+    expect(session.matchId).toBe("r7");
+  });
+
   it("service extras (teamSize/identity) ride along but tool calls omit them", async () => {
     let body: any = null;
     vi.stubGlobal("fetch", vi.fn(async (_u: any, init?: any) => {
@@ -111,3 +123,59 @@ describe("realtime-venue detection (which venue the autoplay watcher drives)", (
     expect(rt?.spec.client?.act.tool).toBe("soccer_play");
   });
 });
+
+describe("join-by-id and leave (the lifecycle gap closed in VA-6)", () => {
+  afterEach(() => { vi.unstubAllGlobals(); _resetSeats(); });
+
+  async function exec(name: string, params: unknown) {
+    const t = generateVenueTools(GOLF_VENUE, GOLF_SPEC, cfg()).find(x => x.name === name)!;
+    const r = await t.execute("id", params as any) as { content: { text: string }[] };
+    return JSON.parse(r.content[0]!.text);
+  }
+
+  it("the join tool routes a matchId param through seatRoute (not the body)", async () => {
+    let url = "", body: any = null;
+    vi.stubGlobal("fetch", vi.fn(async (u: any, init?: any) => {
+      url = String(u); body = JSON.parse(init.body);
+      return { ok: true, json: async () => ({ token: "t", playerIds: ["p1"] }) } as any;
+    }));
+    const out = await exec("golf_join", { matchId: "r9", holes: 9 });
+    expect(url).toBe("http://golf.test/rounds/r9/join"); // seatRoute, not /quickround
+    expect(body.holes).toBe(9);
+    expect(body.matchId).toBeUndefined();               // matchId is routing, never a body field
+    expect(out.joined).toBe("r9");
+  });
+
+  it("omitting matchId quickmatches (find-or-create) via the join route", async () => {
+    let url = "";
+    vi.stubGlobal("fetch", vi.fn(async (u: any) => {
+      url = String(u);
+      return { ok: true, json: async () => ({ matchId: "r1", token: "t", playerIds: ["p1"] }) } as any;
+    }));
+    await exec("golf_join", { holes: 9 });
+    expect(url).toBe("http://golf.test/quickround");
+  });
+
+  it("the leave tool posts to the leave route and frees the seat locally", async () => {
+    // seat first so there's a match to leave
+    vi.stubGlobal("fetch", vi.fn(async () => ({ ok: true, json: async () => ({ matchId: "r5", token: "t", playerIds: ["p1"] }) }) as any));
+    await joinVenue(GOLF_VENUE, GOLF_SPEC, cfg(), { matchId: "r5" });
+    expect(session.matchId).toBe("r5");
+
+    let url = "", method = "";
+    vi.stubGlobal("fetch", vi.fn(async (u: any, init?: any) => {
+      url = String(u); method = init?.method;
+      return { ok: true, json: async () => ({ left: "r5", forfeit: true, winner: "away" }) } as any;
+    }));
+    const out = await exec("golf_leave", {});
+    expect(method).toBe("POST");
+    expect(url).toBe("http://golf.test/rounds/r5/leave");
+    expect(out.left).toBe("r5");
+    expect(session.matchId).toBeNull();   // freed → ready to join elsewhere
+  });
+
+  it("leaving when not in a match is a no-op error, not a crash", async () => {
+    const out = await exec("golf_leave", {});
+    expect(out.error).toMatch(/not in a match/i);
+  });
+});

package/src/generate.ts

@@ -85,7 +85,10 @@ export async function joinVenue(
   const d = r.data;
   if (typeof d.did === "string") rememberDid(cfg, d.did);     // cross-process identity
   if (typeof d.token === "string") rememberToken(cfg, d.token); // cross-process seat token
-  const seat: Seat = { id: d[sm.id], token: d[sm.token], controls: d[sm.controls] ?? [], agentId: d.did ?? meId, started: d.started, managerUrl: d.managerUrl };
+  // A rejoin via seatRoute already KNOWS the room (it's in the URL), so the
+  // server's response omits it — fall back to the matchId we joined with, or
+  // seat.id ends up undefined and the observe loop hits /…//… → 404 → reclaim.
+  const seat: Seat = { id: d[sm.id] ?? opts.matchId, token: d[sm.token], controls: d[sm.controls] ?? [], agentId: d.did ?? meId, started: d.started, managerUrl: d.managerUrl };
   seats.set(venue.id, seat);
   // soccer back-compat: the service watcher + seat-poller read `session`.
   session.matchId = seat.id ?? null; session.players = seat.controls ?? []; session.token = seat.token ?? null; session.did = seat.agentId ?? null;
@@ -117,7 +120,10 @@ export function generateVenueTools(venue: Venue, spec: GameSpec, cfg: PluginCfg)
     out.push({ name: s.tool, label: s.tool, description: s.summary, parameters: paramsSchema(s.params ?? {}),
       async execute(_id, params) {
         try {
-          const seat = await joinVenue(venue, spec, cfg, { params: params as Record<string, unknown> });
+          // matchId (if the spec advertises it) targets a SPECIFIC room via
+          // seatRoute; it's routing, not a body field, so pull it out of params.
+          const { matchId: mid, ...rest } = (params ?? {}) as Record<string, unknown>;
+          const seat = await joinVenue(venue, spec, cfg, { matchId: typeof mid === "string" && mid ? mid : undefined, params: rest });
           return ok({ joined: seat.id, yours: seat.controls, watchUrl: `${base}/matches/${seat.id}/view`, managerUrl: seat.managerUrl,
             note: `seated. observe with ${c.observe.tool}, then ${c.act.tool}.${seat.managerUrl ? " GIVE YOUR HUMAN the managerUrl — their console for this room." : ""}` });
         } catch (e) { return ok({ error: String(e instanceof Error ? e.message : e) }); }
@@ -177,6 +183,23 @@ export function generateVenueTools(venue: Venue, spec: GameSpec, cfg: PluginCfg)
     }
   }
 
+  // leave — exit the current match (a forfeit if it's live). Frees the seat so
+  // the agent can join another room. Server route from spec.client.leave.
+  if (c.leave) {
+    const s = c.leave;
+    out.push({ name: s.tool, label: s.tool, description: s.summary, parameters: paramsSchema(s.params ?? {}),
+      async execute() {
+        const seat = seats.get(venue.id) ?? {}; const d = did(venue.id, cfg);
+        if (!seat.id) return ok({ error: "you are not in a match" });
+        const path = sub(s.route, { matchId: seat.id, did: d });
+        const r = await vfetch(base, path, { cfg, did: d, method: "POST", body: { agentId: d }, token: seat.token });
+        // Clear our seat either way — a failed leave shouldn't leave us wedged.
+        seats.delete(venue.id); session.matchId = null; session.players = []; session.token = null;
+        if (!r.ok) return ok({ error: r.data?.error ?? `leave ${r.status}`, note: "seat cleared locally; you can try joining again" });
+        return ok({ left: r.data?.left ?? seat.id, ...r.data, hint: `you're free — ${c.join?.tool ?? "join"} another room` });
+      } } as AnyAgentTool);
+  }
+
   return out;
 }
 
@@ -223,10 +246,11 @@ const DEFAULT_SPECS: Record<string, GameSpec> = {
     client: {
       prefix: "soccer", noun: "match",
       lobby: { tool: "soccer_matches", route: "/matches", params: { status: { type: "string", enum: ["live", "waiting", "ended"] } }, summary: "List soccer matches: live, open seats, scores." },
-      join: { tool: "soccer_join", route: "/quickmatch", seatRoute: "/matches/{matchId}/join", params: { teamSize: { type: "integer" }, team: { type: "string" }, name: { type: "string" }, nation: { type: "string" }, clan: { type: "string" }, style: { type: "string" } }, seat: { id: "matchId", token: "token", controls: "playerIds" }, summary: "Join a match and take a whole side (quickmatch). The match starts when both sides fill." },
+      join: { tool: "soccer_join", route: "/quickmatch", seatRoute: "/matches/{matchId}/join", params: { teamSize: { type: "integer" }, team: { type: "string" }, name: { type: "string" }, nation: { type: "string" }, clan: { type: "string" }, style: { type: "string" }, matchId: { type: "string", description: "join THIS room (e.g. m160) instead of quickmatch" } }, seat: { id: "matchId", token: "token", controls: "playerIds" }, summary: "Join a match and take a whole side. Pass matchId for a specific room, else quickmatch." },
       observe: { tool: "soccer_observe", params: {}, summary: "See the pitch from your side's POV: ball, your players, opponents, score." },
       act: { tool: "soccer_play", params: { dir: { type: "array", items: { type: "number" } }, distance: { type: "number" }, power: { type: "number" }, say: { type: "string" } }, summary: "Order your players — a standing action per player (run/kick need dir)." },
       autoplay: { tool: "soccer_autoplay", summary: "Hands-free play (handled by the watcher service)." },
+      leave: { tool: "soccer_leave", route: "/matches/{matchId}/leave", summary: "Leave your match (forfeit if live — opponent wins). Frees you to join another room." },
     },
   },
   "taskmarket": {

package/src/tools.ts

@@ -63,6 +63,7 @@ export type GameSpec = {
     observe: { tool: string; params?: Record<string, unknown>; summary: string };
     act: { tool: string; params?: Record<string, unknown>; summary: string };
     autoplay?: { tool: string; summary: string };
+    leave?: { tool: string; route: string; params?: Record<string, unknown>; summary: string } | null;
   };
 };