@myclaw163/clawclaw-cli 0.6.71 → 0.6.76

package/src/commands/events.ts

@@ -1,155 +1,250 @@
-import { Command } from 'commander';
-import { existsSync, readFileSync } from 'fs';
-import { join } from 'path';
-import { AuthStore } from '../lib/auth.js';
-import { getProfileStateDir } from '../lib/init-command.js';
-import { sendOwnerControlRequest } from '../runtime/owner-control.js';
-import { EventRecord, EventStore } from '../pipeline/event-store.js';
-import { compactEventFields, compactStateForEvents } from '../pipeline/event-format.js';
-import { NOTABLE_EVENT_TYPES, nextStepForTriggers } from './watch.js';
-
-interface EventsCommandOptions {
-  last?: string;
-  clear?: boolean;
-  type?: string;
-}
-
-async function readCurrentSummary(): Promise<any | null> {
-  const auth = new AuthStore();
-  const profile = auth.getActive();
-  if (!profile) return null;
-  const stateDir = getProfileStateDir(profile);
-  try {
-    const response = await sendOwnerControlRequest(stateDir, 'snapshot');
-    if (response?.ok) return response.summary ?? null;
-  } catch {}
-  const feedPath = join(stateDir, 'feed.json');
-  if (!existsSync(feedPath)) return null;
-  try {
-    return JSON.parse(readFileSync(feedPath, 'utf8'));
-  } catch {
-    return null;
-  }
-}
-
-function parseCount(value: string | undefined, fallback: number): number {
-  if (!value) return fallback;
-  const parsed = Number.parseInt(value, 10);
-  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
-}
-
-function isMonitorRegisteredRecord(record: EventRecord): boolean {
-  return typeof record.event.type === 'string' && NOTABLE_EVENT_TYPES.has(record.event.type);
-}
-
-export function selectMonitorEventRecordsAfterCursor(
-  records: EventRecord[],
-  fromLine: number,
-): { scanned: EventRecord[]; returned: EventRecord[]; toLine: number } {
-  const scanned = records.filter((record) => record.line > fromLine);
-  const returned = scanned.filter(isMonitorRegisteredRecord);
-  const toLine = scanned.reduce((max, record) => Math.max(max, record.line), fromLine);
-  return { scanned, returned, toLine };
-}
-
-export function selectMonitorTailEventRecords(
-  records: EventRecord[],
-  count: number,
-  type?: string,
-): EventRecord[] {
-  let selected = records.filter(isMonitorRegisteredRecord);
-  if (type) selected = selected.filter((record) => record.event.type === type);
-  return selected.slice(-count);
-}
-
-function eventTypes(records: EventRecord[]): string[] {
-  const out: string[] = [];
-  for (const record of records) {
-    const type = record.event.type;
-    if (typeof type !== 'string' || out.includes(type)) continue;
-    out.push(type);
-  }
-  return out;
-}
-
-export function enrichEventForEvents(event: Record<string, any>, summary: any | null | undefined): Record<string, any> {
-  if (event.type !== 'meeting_briefing') return event;
-  if (event.speech_order) return event;
-  const speechOrder = summary?.meeting?.speech_order;
-  if (!Array.isArray(speechOrder)) return event;
-  const summaryCaller = summary?.meeting?.caller;
-  const eventCaller = event.caller ?? event.meeting_caller_name;
-  if (summaryCaller && eventCaller && summaryCaller !== eventCaller) return event;
-  return { ...event, speech_order: speechOrder };
-}
-
-export function createEventsCommand(): Command {
-  return new Command('events')
-    .alias('e')
-    .description('Query game events')
-    .option('-n, --last <count>', 'Show last N events')
-    .option('--clear', 'Clear event history')
-    .option('--type <type>', 'Filter by event type')
-    .action(async (opts: EventsCommandOptions) => {
-      const store = EventStore.forLatestGame();
-      if (opts.clear) {
-        store.clear();
-        console.log(JSON.stringify({ message: 'Events cleared.' }, null, 2));
-        return;
-      }
-
-      const summary = await readCurrentSummary();
-      const formatContext = {
-        summary,
-      };
-      const state = compactStateForEvents(summary);
-      const debugMode = opts.last !== undefined || opts.type !== undefined;
-
-      if (debugMode) {
-        const count = parseCount(opts.last, 10);
-        let records = selectMonitorTailEventRecords(store.eventRecords(), count, opts.type);
-        records = [...records].sort((a, b) => b.line - a.line);
-        const triggers = eventTypes(records);
-        console.log(JSON.stringify({
-          schema: 'ccl.events.v2',
-          state,
-          exit_reason: triggers,
-          next_step: nextStepForTriggers(triggers),
-          mode: 'tail',
-          session_path: store.path,
-          cursor: null,
-          counts: { returned: records.length },
-          events: records.map((record) => compactEventFields(
-            enrichEventForEvents(record.event, summary),
-            formatContext,
-            record.line,
-          )),
-        }, null, 2));
-        return;
-      }
-
-      const fromLine = store.readEventsCursor();
-      const { scanned, returned, toLine } = selectMonitorEventRecordsAfterCursor(store.eventRecords(), fromLine);
-      const sortedRecords = [...returned].sort((a, b) => b.line - a.line);
-      const triggers = eventTypes(sortedRecords);
-      if (scanned.length > 0) store.appendEventsCursor(toLine);
-
-      console.log(JSON.stringify({
-        schema: 'ccl.events.v2',
-        state,
-        exit_reason: triggers,
-        next_step: nextStepForTriggers(triggers),
-        cursor: {
-          from_line: fromLine,
-          to_line: toLine,
-          advanced: scanned.length > 0,
-        },
-        counts: { returned: sortedRecords.length },
-        events: sortedRecords.map((record) => compactEventFields(
-          enrichEventForEvents(record.event, summary),
-          formatContext,
-          record.line,
-        )),
-      }, null, 2));
-    });
-}
+import { Command, Option } from 'commander';
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+import { AuthStore } from '../lib/auth.js';
+import { GameClient } from '../lib/game-client.js';
+import { buildGameStartedEnrichment } from '../lib/game-context.js';
+import { getProfileStateDir } from '../lib/init-command.js';
+import { sendOwnerControlRequest } from '../runtime/owner-control.js';
+import { EventRecord, EventStore } from '../pipeline/event-store.js';
+import { compactEventFields, compactStateForEvents } from '../pipeline/event-format.js';
+import { NOTABLE_EVENT_TYPES, nextStepForTriggers } from './watch.js';
+
+interface EventsCommandOptions {
+  last?: string;
+  clear?: boolean;
+  type?: string;
+}
+
+async function readCurrentSummary(): Promise<any | null> {
+  const auth = new AuthStore();
+  const profile = auth.getActive();
+  if (!profile) return null;
+  const stateDir = getProfileStateDir(profile);
+  try {
+    const response = await sendOwnerControlRequest(stateDir, 'snapshot');
+    if (response?.ok) return response.summary ?? null;
+  } catch {}
+  const feedPath = join(stateDir, 'feed.json');
+  if (existsSync(feedPath)) {
+    try {
+      return JSON.parse(readFileSync(feedPath, 'utf8'));
+    } catch {
+      // Fall through to live HTTP state.
+    }
+  }
+  try {
+    const client = GameClient.fromAuth();
+    await client.discoverGameServer();
+    return await client.getGameState();
+  } catch {
+    return null;
+  }
+}
+
+function parseCount(value: string | undefined, fallback: number): number {
+  if (!value) return fallback;
+  const parsed = Number.parseInt(value, 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}
+
+function isMonitorRegisteredRecord(record: EventRecord): boolean {
+  return typeof record.event.type === 'string' && NOTABLE_EVENT_TYPES.has(record.event.type);
+}
+
+export function selectMonitorEventRecordsAfterCursor(
+  records: EventRecord[],
+  fromLine: number,
+): { scanned: EventRecord[]; returned: EventRecord[]; toLine: number } {
+  const scanned = records.filter((record) => record.line > fromLine);
+  const returned = scanned.filter(isMonitorRegisteredRecord);
+  const toLine = scanned.reduce((max, record) => Math.max(max, record.line), fromLine);
+  return { scanned, returned, toLine };
+}
+
+export function selectMonitorTailEventRecords(
+  records: EventRecord[],
+  count: number,
+  type?: string,
+): EventRecord[] {
+  let selected = records.filter(isMonitorRegisteredRecord);
+  if (type) selected = selected.filter((record) => record.event.type === type);
+  return selected.slice(-count);
+}
+
+function eventTypes(records: EventRecord[]): string[] {
+  const out: string[] = [];
+  for (const record of records) {
+    const type = record.event.type;
+    if (typeof type !== 'string' || out.includes(type)) continue;
+    out.push(type);
+  }
+  return out;
+}
+
+function latestEventRecord(records: EventRecord[], type: string): EventRecord | null {
+  for (let i = records.length - 1; i >= 0; i -= 1) {
+    const record = records[i];
+    if (record.event.type === type) return record;
+  }
+  return null;
+}
+
+function hasOpeningRoster(source: any): boolean {
+  return Array.isArray(source?.players) && source.players.length > 0
+    || Array.isArray(source?.all_players) && source.all_players.length > 0
+    || Array.isArray(source?.game?.all_players) && source.game.all_players.length > 0
+    || !!(source?.all_seats && typeof source.all_seats === 'object' && !Array.isArray(source.all_seats))
+    || !!(source?.game?.all_seats && typeof source.game.all_seats === 'object' && !Array.isArray(source.game.all_seats));
+}
+
+export function enrichEventsForState(
+  events: Array<Record<string, any>>,
+  openingContext: Record<string, any> | null | undefined,
+): Array<Record<string, any>> {
+  if (!openingContext || !hasOpeningRoster(openingContext)) return events;
+  const index = (() => {
+    for (let i = events.length - 1; i >= 0; i -= 1) {
+      if (events[i]?.type === 'game_started') return i;
+    }
+    return -1;
+  })();
+  if (index < 0 || hasOpeningRoster(events[index])) return events;
+  return events.map((event, i) => (i === index ? { ...event, ...openingContext } : event));
+}
+
+async function readGameStartedEnrichment(): Promise<Record<string, any> | null> {
+  try {
+    const client = GameClient.fromAuth();
+    await client.discoverGameServer();
+    const mapData = await client.getMap();
+    return buildGameStartedEnrichment(mapData);
+  } catch {
+    return null;
+  }
+}
+
+export function enrichEventForEvents(event: Record<string, any>, summary: any | null | undefined): Record<string, any> {
+  if (event.type !== 'meeting_briefing') return event;
+  if (event.speech_order) return event;
+  const speechOrder = summary?.meeting?.speech_order;
+  if (!Array.isArray(speechOrder)) return event;
+  const summaryCaller = summary?.meeting?.caller;
+  const eventCaller = event.caller ?? event.meeting_caller_name;
+  if (summaryCaller && eventCaller && summaryCaller !== eventCaller) return event;
+  return { ...event, speech_order: speechOrder };
+}
+
+async function enrichLatestEventForEvents(
+  event: Record<string, any>,
+  summary: any | null | undefined,
+): Promise<Record<string, any>> {
+  const base = enrichEventForEvents(event, summary);
+  if (base.type !== 'game_started') return base;
+  const enrichment = await readGameStartedEnrichment();
+  if (!enrichment) return base;
+  return {
+    ...base,
+    ...enrichment,
+    map: {
+      ...(base.map && typeof base.map === 'object' ? base.map : {}),
+      ...(enrichment.map ?? {}),
+    },
+  };
+}
+
+export function createEventsCommand(): Command {
+  return new Command('events')
+    .alias('e')
+    .description('Query game events')
+    .argument('[event_type]', 'Return the latest full payload for this event type without advancing the cursor')
+    .option('-n, --last <count>', 'Show last N events')
+    .addOption(new Option('--clear', 'Clear event history').hideHelp())
+    .option('--type <type>', 'Filter by event type')
+    .action(async (eventType: string | undefined, opts: EventsCommandOptions) => {
+      const store = EventStore.forLatestGame();
+      if (opts.clear) {
+        store.clear();
+        console.log(JSON.stringify({ message: 'Events cleared.' }, null, 2));
+        return;
+      }
+
+      const summary = await readCurrentSummary();
+      const allEvents = store.all();
+      const needsOpeningContext = !hasOpeningRoster(summary)
+        && allEvents.some((event) => event?.type === 'game_started' && !hasOpeningRoster(event));
+      const openingContext = needsOpeningContext
+        ? await readGameStartedEnrichment()
+        : null;
+      const stateEvents = enrichEventsForState(allEvents, openingContext);
+      const formatContext = {
+        summary,
+      };
+      const state = compactStateForEvents(summary, stateEvents);
+      if (eventType) {
+        const record = latestEventRecord(store.eventRecords(), eventType);
+        const event = record
+          ? await enrichLatestEventForEvents(record.event, summary)
+          : null;
+        console.log(JSON.stringify({
+          schema: 'ccl.events.v3',
+          mode: 'latest_event',
+          query: { type: eventType },
+          state,
+          found: !!record,
+          session_path: store.path,
+          line: record?.line ?? null,
+          event,
+        }, null, 2));
+        return;
+      }
+      const debugMode = opts.last !== undefined || opts.type !== undefined;
+
+      if (debugMode) {
+        const count = parseCount(opts.last, 10);
+        let records = selectMonitorTailEventRecords(store.eventRecords(), count, opts.type);
+        records = [...records].sort((a, b) => b.line - a.line);
+        const triggers = eventTypes(records);
+        console.log(JSON.stringify({
+          schema: 'ccl.events.v3',
+          state,
+          exit_reason: triggers,
+          next_step: nextStepForTriggers(triggers),
+          mode: 'tail',
+          session_path: store.path,
+          cursor: null,
+          counts: { returned: records.length },
+          events: records.map((record) => compactEventFields(
+            enrichEventForEvents(record.event, summary),
+            formatContext,
+            record.line,
+          )),
+        }, null, 2));
+        return;
+      }
+
+      const fromLine = store.readEventsCursor();
+      const { scanned, returned, toLine } = selectMonitorEventRecordsAfterCursor(store.eventRecords(), fromLine);
+      const sortedRecords = [...returned].sort((a, b) => b.line - a.line);
+      const triggers = eventTypes(sortedRecords);
+      if (scanned.length > 0) store.appendEventsCursor(toLine);
+
+      console.log(JSON.stringify({
+        schema: 'ccl.events.v3',
+        state,
+        exit_reason: triggers,
+        next_step: nextStepForTriggers(triggers),
+        cursor: {
+          from_line: fromLine,
+          to_line: toLine,
+          advanced: scanned.length > 0,
+        },
+        counts: { returned: sortedRecords.length },
+        events: sortedRecords.map((record) => compactEventFields(
+          enrichEventForEvents(record.event, summary),
+          formatContext,
+          record.line,
+        )),
+      }, null, 2));
+    });
+}

package/src/commands/game-map.test.ts

@@ -1,28 +1,28 @@
-import { describe, expect, it } from 'vitest';
-import { summarizeGameMap } from './game.js';
-
-const mapData = {
-  rooms: [{ name: '酒吧', polygon: [[1, 2]] }],
-  all_task_locations: [
-    { name: '修线', room: '酒吧', x: 1, y: 2, faction: 'lobster' },
-    { name: '破坏', room: '控制室', x: 3, y: 4, faction: 'crab' },
-  ],
-};
-
-describe('summarizeGameMap', () => {
-  it('does not include ASCII by default', () => {
-    const summary = summarizeGameMap(mapData);
-    expect(summary.rooms).toEqual([{ name: '酒吧', polygon: [[1, 2]] }]);
-    expect(summary.task_locations.lobster).toEqual([{ name: '修线', room: '酒吧', x: 1, y: 2 }]);
-    expect(summary.task_locations.crab).toEqual([{ name: '破坏', room: '控制室', x: 3, y: 4 }]);
-    expect(summary).not.toHaveProperty('ascii_map');
-  });
-
-  it('includes packaged ASCII map only with --ascii', () => {
-    const summary = summarizeGameMap(mapData, { ascii: true });
-    expect(typeof summary.ascii_map).toBe('string');
-    expect(summary.ascii_map).toContain('酒吧');
-    expect(summary.ascii_map).toContain('5号走廊');
-    expect(summary).not.toHaveProperty('corridors');
-  });
-});
+import { describe, expect, it } from 'vitest';
+import { summarizeGameMap } from './game.js';
+
+const mapData = {
+  rooms: [{ name: '酒吧', polygon: [[1, 2]] }],
+  all_task_locations: [
+    { name: '修线', room: '酒吧', x: 1, y: 2, faction: 'lobster' },
+    { name: '破坏', room: '控制室', x: 3, y: 4, faction: 'crab' },
+  ],
+};
+
+describe('summarizeGameMap', () => {
+  it('does not include ASCII by default', () => {
+    const summary = summarizeGameMap(mapData);
+    expect(summary.rooms).toEqual([{ name: '酒吧', polygon: [[1, 2]] }]);
+    expect(summary.task_locations.lobster).toEqual([{ name: '修线', room: '酒吧', x: 1, y: 2 }]);
+    expect(summary.task_locations.crab).toEqual([{ name: '破坏', room: '控制室', x: 3, y: 4 }]);
+    expect(summary).not.toHaveProperty('ascii_map');
+  });
+
+  it('includes packaged ASCII map only with --ascii', () => {
+    const summary = summarizeGameMap(mapData, { ascii: true });
+    expect(typeof summary.ascii_map).toBe('string');
+    expect(summary.ascii_map).toContain('酒吧');
+    expect(summary.ascii_map).toContain('5号走廊');
+    expect(summary).not.toHaveProperty('corridors');
+  });
+});

package/src/commands/game-start-plan.test.ts

@@ -1,84 +1,84 @@
-import { describe, expect, it } from 'vitest';
-import {
-  gameStrategyIdentity,
-  planGameStartAction,
-} from './game.js';
-
-describe('planGameStartAction', () => {
-  it('returns the running game start pid when a stream is already alive', () => {
-    expect(planGameStartAction({
-      gameStartPid: 1234,
-      hasMatchState: true,
-      queueStatus: 'allocated',
-    })).toEqual({ kind: 'already_running', pid: 1234 });
-  });
-
-  it('resumes queue polling from backend queue state', () => {
-    expect(planGameStartAction({
-      hasMatchState: true,
-      queueStatus: 'queued',
-    })).toEqual({ kind: 'resume_queue' });
-  });
-
-  it('ignores stale local match state when backend says not in queue', () => {
-    expect(planGameStartAction({
-      hasMatchState: true,
-      queueStatus: 'not_in_queue',
-    })).toEqual({ kind: 'fresh_start' });
-  });
-
-  it('resumes queue polling from local match state when backend status is unavailable', () => {
-    expect(planGameStartAction({
-      hasMatchState: true,
-      queueStatus: undefined,
-    })).toEqual({ kind: 'resume_queue' });
-  });
-
-  it('resumes an allocated match when no owner runtime is alive', () => {
-    expect(planGameStartAction({
-      hasMatchState: false,
-      queueStatus: 'allocated',
-    })).toEqual({ kind: 'resume_allocated' });
-  });
-
-  it('resumes queue polling for queued and already_in_queue states without an owner runtime', () => {
-    for (const queueStatus of ['queued', 'already_in_queue']) {
-      expect(planGameStartAction({
-        hasMatchState: false,
-        queueStatus,
-      })).toEqual({ kind: 'resume_queue' });
-    }
-  });
-
-  it('starts fresh when no stream, runtime, or queue state can be recovered', () => {
-    expect(planGameStartAction({
-      hasMatchState: false,
-      queueStatus: 'not_in_queue',
-    })).toEqual({ kind: 'fresh_start' });
-  });
-});
-
-describe('game strategy identity', () => {
-  it('derives game id, role, and alive status from current server context', () => {
-    expect(gameStrategyIdentity(
-      { game_id: 'game-1', you: { role: 'shrimp_generic', is_alive: false } },
-      null,
-    )).toEqual({
-      gameId: 'game-1',
-      role: 'shrimp_generic',
-      alive: false,
-    });
-  });
-
-  it('prefers role_info role over state role', () => {
-    expect(gameStrategyIdentity(
-      { game_id: 'game-1', you: { role: 'shrimp_generic', is_alive: true } },
-      { data: { role: 'crab_generic' } },
-    )).toEqual({
-      gameId: 'game-1',
-      role: 'crab_generic',
-      alive: true,
-    });
-  });
-
-});
+import { describe, expect, it } from 'vitest';
+import {
+  gameStrategyIdentity,
+  planGameStartAction,
+} from './game.js';
+
+describe('planGameStartAction', () => {
+  it('returns the running game start pid when a stream is already alive', () => {
+    expect(planGameStartAction({
+      gameStartPid: 1234,
+      hasMatchState: true,
+      queueStatus: 'allocated',
+    })).toEqual({ kind: 'already_running', pid: 1234 });
+  });
+
+  it('resumes queue polling from backend queue state', () => {
+    expect(planGameStartAction({
+      hasMatchState: true,
+      queueStatus: 'queued',
+    })).toEqual({ kind: 'resume_queue' });
+  });
+
+  it('ignores stale local match state when backend says not in queue', () => {
+    expect(planGameStartAction({
+      hasMatchState: true,
+      queueStatus: 'not_in_queue',
+    })).toEqual({ kind: 'fresh_start' });
+  });
+
+  it('resumes queue polling from local match state when backend status is unavailable', () => {
+    expect(planGameStartAction({
+      hasMatchState: true,
+      queueStatus: undefined,
+    })).toEqual({ kind: 'resume_queue' });
+  });
+
+  it('resumes an allocated match when no owner runtime is alive', () => {
+    expect(planGameStartAction({
+      hasMatchState: false,
+      queueStatus: 'allocated',
+    })).toEqual({ kind: 'resume_allocated' });
+  });
+
+  it('resumes queue polling for queued and already_in_queue states without an owner runtime', () => {
+    for (const queueStatus of ['queued', 'already_in_queue']) {
+      expect(planGameStartAction({
+        hasMatchState: false,
+        queueStatus,
+      })).toEqual({ kind: 'resume_queue' });
+    }
+  });
+
+  it('starts fresh when no stream, runtime, or queue state can be recovered', () => {
+    expect(planGameStartAction({
+      hasMatchState: false,
+      queueStatus: 'not_in_queue',
+    })).toEqual({ kind: 'fresh_start' });
+  });
+});
+
+describe('game strategy identity', () => {
+  it('derives game id, role, and alive status from current server context', () => {
+    expect(gameStrategyIdentity(
+      { game_id: 'game-1', you: { role: 'shrimp_generic', is_alive: false } },
+      null,
+    )).toEqual({
+      gameId: 'game-1',
+      role: 'shrimp_generic',
+      alive: false,
+    });
+  });
+
+  it('prefers role_info role over state role', () => {
+    expect(gameStrategyIdentity(
+      { game_id: 'game-1', you: { role: 'shrimp_generic', is_alive: true } },
+      { data: { role: 'crab_generic' } },
+    )).toEqual({
+      gameId: 'game-1',
+      role: 'crab_generic',
+      alive: true,
+    });
+  });
+
+});