@myclaw163/clawclaw-cli 0.6.71 → 0.6.74

package/src/pipeline/player-projection.ts

@@ -0,0 +1,380 @@
+export type PlayerStatus = 'alive' | 'dead';
+
+export interface PlayerDeathProjection {
+  cause: 'killed' | 'exiled' | 'self_destruct';
+  killer?: string | null;
+  killer_is_you?: boolean;
+  revealed: boolean;
+  source: string;
+}
+
+export interface PlayerProjection {
+  name: string;
+  seat?: number;
+  status: PlayerStatus;
+  death: PlayerDeathProjection | null;
+}
+
+interface MutablePlayerProjection extends PlayerProjection {
+  key: string;
+}
+
+function cleanObject<T extends Record<string, any>>(obj: T): T {
+  for (const key of Object.keys(obj)) {
+    if (obj[key] === undefined) delete obj[key];
+  }
+  return obj;
+}
+
+function numberValue(value: unknown): number | undefined {
+  if (typeof value === 'number' && Number.isFinite(value)) return value;
+  if (typeof value === 'string' && value.trim() !== '') {
+    const parsed = Number(value);
+    if (Number.isFinite(parsed)) return parsed;
+  }
+  return undefined;
+}
+
+function stringValue(value: unknown): string | undefined {
+  if (typeof value === 'string' && value.length > 0) return value;
+  if (typeof value === 'number' && Number.isFinite(value)) return String(value);
+  return undefined;
+}
+
+function deathCause(value: unknown): PlayerDeathProjection['cause'] {
+  return value === 'killed' || value === 'exiled' || value === 'self_destruct'
+    ? value
+    : 'killed';
+}
+
+function firstString(source: Record<string, any>, keys: string[]): string | undefined {
+  for (const key of keys) {
+    const value = stringValue(source[key]);
+    if (value) return value;
+  }
+  return undefined;
+}
+
+function firstNumber(source: Record<string, any>, keys: string[]): number | undefined {
+  for (const key of keys) {
+    const value = numberValue(source[key]);
+    if (value !== undefined) return value;
+  }
+  return undefined;
+}
+
+function playerKey(name?: string, seat?: number): string | null {
+  if (seat !== undefined) return `seat:${seat}`;
+  if (name) return `name:${name}`;
+  return null;
+}
+
+function findPlayerByName(
+  players: Map<string, MutablePlayerProjection>,
+  name: string | undefined,
+): MutablePlayerProjection | null {
+  if (!name) return null;
+  for (const player of players.values()) {
+    if (player.name === name) return player;
+  }
+  return null;
+}
+
+function movePlayerKey(
+  players: Map<string, MutablePlayerProjection>,
+  player: MutablePlayerProjection,
+  key: string,
+): MutablePlayerProjection {
+  if (player.key === key) return player;
+  players.delete(player.key);
+  player.key = key;
+  players.set(key, player);
+  return player;
+}
+
+function getOrRemember(
+  players: Map<string, MutablePlayerProjection>,
+  name?: string,
+  seat?: number,
+): MutablePlayerProjection | null {
+  const key = playerKey(name, seat);
+  if (!key) return null;
+  const existing = players.get(key);
+  if (existing) {
+    if ((!existing.name || existing.name === `seat:${existing.seat}`) && name) existing.name = name;
+    if (existing.seat === undefined && seat !== undefined) existing.seat = seat;
+    return existing;
+  }
+  const named = findPlayerByName(players, name);
+  if (named) {
+    if (named.seat === undefined && seat !== undefined) named.seat = seat;
+    return seat !== undefined ? movePlayerKey(players, named, key) : named;
+  }
+  const created: MutablePlayerProjection = {
+    key,
+    name: name ?? `seat:${seat}`,
+    seat,
+    status: 'alive',
+    death: null,
+  };
+  players.set(key, created);
+  return created;
+}
+
+function rememberPlayer(players: Map<string, MutablePlayerProjection>, player: any): void {
+  if (typeof player === 'string') {
+    getOrRemember(players, player, undefined);
+    return;
+  }
+  if (!player || typeof player !== 'object') return;
+  const name = stringValue(player.name ?? player.agent_name ?? player.player_name);
+  const seat = numberValue(player.seat ?? player.player_seat);
+  getOrRemember(players, name, seat);
+}
+
+function markAlive(players: Map<string, MutablePlayerProjection>, name?: string, seat?: number): void {
+  const player = getOrRemember(players, name, seat);
+  if (!player || player.death) return;
+  player.status = 'alive';
+}
+
+function markDead(
+  players: Map<string, MutablePlayerProjection>,
+  name: string | undefined,
+  seat: number | undefined,
+  death: PlayerDeathProjection,
+): void {
+  const player = getOrRemember(players, name, seat);
+  if (!player) return;
+  player.status = 'dead';
+  player.death = cleanObject({ ...death });
+}
+
+function rememberRoster(players: Map<string, MutablePlayerProjection>, source: any): void {
+  const collections = [
+    source?.players,
+    source?.all_players,
+    source?.visible_players,
+    source?.game?.players,
+    source?.game?.all_players,
+    source?.global?.players,
+  ];
+  for (const collection of collections) {
+    if (!Array.isArray(collection)) continue;
+    for (const player of collection) rememberPlayer(players, player);
+  }
+
+  const allSeats = source?.all_seats ?? source?.game?.all_seats;
+  if (allSeats && typeof allSeats === 'object' && !Array.isArray(allSeats)) {
+    for (const [name, seat] of Object.entries(allSeats)) {
+      getOrRemember(players, stringValue(name), numberValue(seat));
+    }
+  }
+}
+
+function applyVisibleState(players: Map<string, MutablePlayerProjection>, summary: any | null | undefined): void {
+  if (!summary || typeof summary !== 'object') return;
+  for (const player of Array.isArray(summary.visible_players) ? summary.visible_players : []) {
+    if (typeof player === 'string') markAlive(players, player, undefined);
+    else markAlive(players, stringValue(player?.name ?? player?.agent_name), numberValue(player?.seat));
+  }
+  const alivePlayers = Array.isArray(summary.meeting?.alive_players) ? summary.meeting.alive_players : [];
+  for (const player of alivePlayers) {
+    if (typeof player === 'string') markAlive(players, player, undefined);
+    else markAlive(players, stringValue(player?.name ?? player?.agent_name), numberValue(player?.seat));
+  }
+
+  const snapshotPlayers = [
+    ...(Array.isArray(summary.players) ? summary.players : []),
+    ...(Array.isArray(summary.global?.players) ? summary.global.players : []),
+    ...(Array.isArray(summary.game?.players) ? summary.game.players : []),
+  ];
+  for (const player of snapshotPlayers) {
+    if (!player || typeof player !== 'object') continue;
+    const name = stringValue(player.name ?? player.agent_name);
+    const seat = numberValue(player.seat);
+    rememberPlayer(players, player);
+    const dead = player.is_dead === true || player.is_alive === false || player.alive === false;
+    if (dead) {
+      markDead(players, name, seat, {
+        cause: deathCause(player.death_cause),
+        killer: stringValue(player.killer_name ?? player.death_killer_name) ?? null,
+        revealed: true,
+        source: 'backend_state',
+      });
+    } else {
+      markAlive(players, name, seat);
+    }
+  }
+}
+
+function applyMeetingAliveList(players: Map<string, MutablePlayerProjection>, event: Record<string, any>): void {
+  const alive = Array.isArray(event.alive_players) ? event.alive_players : [];
+  if (alive.length === 0 || players.size === 0) return;
+  const aliveNames = new Set<string>();
+  const aliveSeats = new Set<number>();
+  for (const player of alive) {
+    if (typeof player === 'string') {
+      aliveNames.add(player);
+      markAlive(players, player, undefined);
+    } else {
+      const name = stringValue(player?.name ?? player?.agent_name);
+      const seat = numberValue(player?.seat);
+      if (name) aliveNames.add(name);
+      if (seat !== undefined) aliveSeats.add(seat);
+      markAlive(players, name, seat);
+    }
+  }
+
+  for (const player of players.values()) {
+    const listed = (player.name && aliveNames.has(player.name)) || (player.seat !== undefined && aliveSeats.has(player.seat));
+    if (listed || player.death) continue;
+    markDead(players, player.name, player.seat, {
+      cause: 'killed',
+      killer: null,
+      revealed: true,
+      source: 'meeting_alive_list',
+    });
+  }
+}
+
+function applyEvent(
+  players: Map<string, MutablePlayerProjection>,
+  event: Record<string, any>,
+  youName?: string,
+): void {
+  rememberRoster(players, event);
+  switch (event.type) {
+    case 'kill': {
+      const target = firstString(event, ['target_name', 'target']);
+      const targetSeat = firstNumber(event, ['target_seat', 'target_player_seat']);
+      const killer = firstString(event, ['killer_name', 'actor_name']) ?? youName;
+      markDead(players, target, targetSeat, {
+        cause: 'killed',
+        killer: killer ?? null,
+        killer_is_you: killer !== undefined && killer === youName,
+        revealed: true,
+        source: 'event_log',
+      });
+      break;
+    }
+    case 'killed': {
+      const target = firstString(event, ['target_name', 'victim_name']) ?? youName;
+      const targetSeat = firstNumber(event, ['target_seat', 'target_player_seat']);
+      markDead(players, target, targetSeat, {
+        cause: 'killed',
+        killer: firstString(event, ['killer_name']) ?? null,
+        revealed: true,
+        source: 'event_log',
+      });
+      break;
+    }
+    case 'murder_witnessed': {
+      const killer = firstString(event, ['killer_name']);
+      markDead(players, firstString(event, ['target_name']), firstNumber(event, ['target_seat', 'target_player_seat']), {
+        cause: 'killed',
+        killer: killer ?? null,
+        killer_is_you: killer !== undefined && killer === youName,
+        revealed: true,
+        source: 'event_log',
+      });
+      break;
+    }
+    case 'corpse_spotted':
+    case 'body_dropped': {
+      markDead(players, firstString(event, ['corpse_name', 'target_name', 'name']), firstNumber(event, ['corpse_seat', 'corpse_player_seat', 'target_seat']), {
+        cause: 'killed',
+        killer: null,
+        revealed: true,
+        source: event.type,
+      });
+      break;
+    }
+    case 'meeting_briefing': {
+      const corpses = Array.isArray(event.reported_corpses) ? event.reported_corpses : [];
+      for (const corpse of corpses) {
+        if (!corpse || typeof corpse !== 'object') continue;
+        markDead(players, stringValue(corpse.name ?? corpse.agent_name), numberValue(corpse.seat), {
+          cause: 'killed',
+          killer: null,
+          revealed: true,
+          source: 'meeting',
+        });
+      }
+      markDead(players, firstString(event, ['corpse_name']), firstNumber(event, ['corpse_seat', 'corpse_player_seat']), {
+        cause: 'killed',
+        killer: null,
+        revealed: true,
+        source: 'meeting',
+      });
+      break;
+    }
+    case 'exile':
+      markDead(players, firstString(event, ['result_target', 'actor_name']), firstNumber(event, ['result_target_seat', 'actor_seat', 'seat']), {
+        cause: 'exiled',
+        killer: null,
+        revealed: true,
+        source: 'meeting',
+      });
+      break;
+    case 'meeting_ended':
+      if (event.result === 'exiled') {
+        markDead(players, firstString(event, ['result_target', 'actor_name']), firstNumber(event, ['result_target_seat', 'actor_seat', 'seat']), {
+          cause: 'exiled',
+          killer: null,
+          revealed: true,
+          source: 'meeting',
+        });
+      }
+      break;
+    case 'warrior_shrimp_self_destruct': {
+      const actor = firstString(event, ['actor_name', 'self_name']);
+      markDead(players, actor, firstNumber(event, ['actor_seat', 'seat']), {
+        cause: 'self_destruct',
+        killer: null,
+        revealed: true,
+        source: 'event_log',
+      });
+      markDead(players, firstString(event, ['target_name']), firstNumber(event, ['target_seat', 'target_player_seat']), {
+        cause: 'killed',
+        killer: actor ?? null,
+        killer_is_you: actor !== undefined && actor === youName,
+        revealed: true,
+        source: 'event_log',
+      });
+      break;
+    }
+    case 'meeting_state':
+      applyMeetingAliveList(players, event);
+      break;
+    default:
+      break;
+  }
+}
+
+export function projectPlayers(input: {
+  summary?: any | null;
+  events?: Array<Record<string, any>>;
+}): PlayerProjection[] {
+  const players = new Map<string, MutablePlayerProjection>();
+  const youName = stringValue(input.summary?.you?.name);
+
+  rememberRoster(players, input.summary);
+  for (const event of input.events ?? []) applyEvent(players, event, youName);
+  applyVisibleState(players, input.summary);
+
+  return [...players.values()]
+    .filter((player) => player.name && player.name !== youName)
+    .sort((a, b) => {
+      if (a.seat !== undefined && b.seat !== undefined) return a.seat - b.seat;
+      if (a.seat !== undefined) return -1;
+      if (b.seat !== undefined) return 1;
+      return a.name.localeCompare(b.name);
+    })
+    .map((player) => cleanObject({
+      name: player.name,
+      seat: player.seat,
+      status: player.status,
+      death: player.death,
+    }));
+}

package/src/runtime/auto-upgrade.test.ts

@@ -1,66 +1,66 @@
-import { describe, expect, it, vi, beforeEach, afterEach } from 'vitest';
-
-vi.mock('../commands/upgrade.js', () => ({
-  runDefaultUpgrade: vi.fn(),
-}));
-
-import { runDefaultUpgrade } from '../commands/upgrade.js';
-import { runAutoUpgradeOnLoad, shouldSkipAutoUpgrade } from './auto-upgrade.js';
-
-describe('runAutoUpgradeOnLoad', () => {
-  const prev = process.env.CLAWCLAW_SKIP_AUTO_UPGRADE;
-
-  beforeEach(() => {
-    vi.mocked(runDefaultUpgrade).mockReset();
-    delete process.env.CLAWCLAW_SKIP_AUTO_UPGRADE;
-  });
-
-  afterEach(() => {
-    if (prev === undefined) delete process.env.CLAWCLAW_SKIP_AUTO_UPGRADE;
-    else process.env.CLAWCLAW_SKIP_AUTO_UPGRADE = prev;
-  });
-
-  it('skips when CLAWCLAW_SKIP_AUTO_UPGRADE=1', () => {
-    process.env.CLAWCLAW_SKIP_AUTO_UPGRADE = '1';
-    runAutoUpgradeOnLoad({ packageVersion: '0.5.25' });
-    expect(runDefaultUpgrade).not.toHaveBeenCalled();
-  });
-
-  it('skips prerelease/test package versions', () => {
-    runAutoUpgradeOnLoad({ packageVersion: '0.5.25-test' });
-    expect(runDefaultUpgrade).not.toHaveBeenCalled();
-  });
-
-  it('runs default upgrade when not skipped', () => {
-    vi.mocked(runDefaultUpgrade).mockReturnValue({ version: '0.4.8' });
-    runAutoUpgradeOnLoad({ packageVersion: '0.5.25' });
-    expect(runDefaultUpgrade).toHaveBeenCalledOnce();
-  });
-
-  it('does not write upgrade progress to stdout', () => {
-    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
-    vi.mocked(runDefaultUpgrade).mockReturnValue({ version: '0.4.8' });
-    try {
-      runAutoUpgradeOnLoad({ packageVersion: '0.5.25' });
-      expect(logSpy).not.toHaveBeenCalled();
-    } finally {
-      logSpy.mockRestore();
-    }
-  });
-
-  it('notifies on upgrade success and failure', () => {
-    const notify = vi.fn();
-    vi.mocked(runDefaultUpgrade).mockReturnValueOnce({ version: '0.4.8' });
-    runAutoUpgradeOnLoad({ packageVersion: '0.5.25', notify });
-    expect(notify).toHaveBeenCalledWith('[clawclaw-cli] auto-upgrade installed 0.4.8');
-
-    vi.mocked(runDefaultUpgrade).mockReturnValueOnce({ error: 'npm install failed: EACCES' });
-    runAutoUpgradeOnLoad({ packageVersion: '0.5.25', notify });
-    expect(notify).toHaveBeenCalledWith('[clawclaw-cli] auto-upgrade failed: npm install failed: EACCES');
-  });
-
-  it('treats prerelease versions as skip-worthy', () => {
-    expect(shouldSkipAutoUpgrade('0.5.25-test')).toBe(true);
-    expect(shouldSkipAutoUpgrade('0.5.25')).toBe(false);
-  });
-});
+import { describe, expect, it, vi, beforeEach, afterEach } from 'vitest';
+
+vi.mock('../commands/upgrade.js', () => ({
+  runDefaultUpgrade: vi.fn(),
+}));
+
+import { runDefaultUpgrade } from '../commands/upgrade.js';
+import { runAutoUpgradeOnLoad, shouldSkipAutoUpgrade } from './auto-upgrade.js';
+
+describe('runAutoUpgradeOnLoad', () => {
+  const prev = process.env.CLAWCLAW_SKIP_AUTO_UPGRADE;
+
+  beforeEach(() => {
+    vi.mocked(runDefaultUpgrade).mockReset();
+    delete process.env.CLAWCLAW_SKIP_AUTO_UPGRADE;
+  });
+
+  afterEach(() => {
+    if (prev === undefined) delete process.env.CLAWCLAW_SKIP_AUTO_UPGRADE;
+    else process.env.CLAWCLAW_SKIP_AUTO_UPGRADE = prev;
+  });
+
+  it('skips when CLAWCLAW_SKIP_AUTO_UPGRADE=1', () => {
+    process.env.CLAWCLAW_SKIP_AUTO_UPGRADE = '1';
+    runAutoUpgradeOnLoad({ packageVersion: '0.5.25' });
+    expect(runDefaultUpgrade).not.toHaveBeenCalled();
+  });
+
+  it('skips prerelease/test package versions', () => {
+    runAutoUpgradeOnLoad({ packageVersion: '0.5.25-test' });
+    expect(runDefaultUpgrade).not.toHaveBeenCalled();
+  });
+
+  it('runs default upgrade when not skipped', () => {
+    vi.mocked(runDefaultUpgrade).mockReturnValue({ version: '0.4.8' });
+    runAutoUpgradeOnLoad({ packageVersion: '0.5.25' });
+    expect(runDefaultUpgrade).toHaveBeenCalledOnce();
+  });
+
+  it('does not write upgrade progress to stdout', () => {
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    vi.mocked(runDefaultUpgrade).mockReturnValue({ version: '0.4.8' });
+    try {
+      runAutoUpgradeOnLoad({ packageVersion: '0.5.25' });
+      expect(logSpy).not.toHaveBeenCalled();
+    } finally {
+      logSpy.mockRestore();
+    }
+  });
+
+  it('notifies on upgrade success and failure', () => {
+    const notify = vi.fn();
+    vi.mocked(runDefaultUpgrade).mockReturnValueOnce({ version: '0.4.8' });
+    runAutoUpgradeOnLoad({ packageVersion: '0.5.25', notify });
+    expect(notify).toHaveBeenCalledWith('[clawclaw-cli] auto-upgrade installed 0.4.8');
+
+    vi.mocked(runDefaultUpgrade).mockReturnValueOnce({ error: 'npm install failed: EACCES' });
+    runAutoUpgradeOnLoad({ packageVersion: '0.5.25', notify });
+    expect(notify).toHaveBeenCalledWith('[clawclaw-cli] auto-upgrade failed: npm install failed: EACCES');
+  });
+
+  it('treats prerelease versions as skip-worthy', () => {
+    expect(shouldSkipAutoUpgrade('0.5.25-test')).toBe(true);
+    expect(shouldSkipAutoUpgrade('0.5.25')).toBe(false);
+  });
+});

package/src/runtime/auto-upgrade.ts

@@ -1,31 +1,31 @@
-import { readFileSync } from 'fs';
-import { runDefaultUpgrade } from '../commands/upgrade.js';
-
-function readPackageVersion(): string | null {
-  try {
-    const pkg = JSON.parse(readFileSync(new URL('../../package.json', import.meta.url), 'utf8'));
-    return typeof pkg?.version === 'string' ? pkg.version : null;
-  } catch {
-    return null;
-  }
-}
-
-export function shouldSkipAutoUpgrade(packageVersion = readPackageVersion()): boolean {
-  if (process.env.CLAWCLAW_SKIP_AUTO_UPGRADE === '1') return true;
-  return Boolean(packageVersion?.includes('-'));
-}
-
-/** Run during `ccl load`, before game start and event streaming begin. */
-export function runAutoUpgradeOnLoad(options?: { packageVersion?: string; notify?: (message: string) => void }): void {
-  if (shouldSkipAutoUpgrade(options?.packageVersion)) return;
-
-  const result = runDefaultUpgrade();
-  if (result.error) {
-    const msg = result.version ? `${result.version} (${result.error})` : result.error;
-    options?.notify?.(`[clawclaw-cli] auto-upgrade failed: ${msg}`);
-    return;
-  }
-  if (result.version) {
-    options?.notify?.(`[clawclaw-cli] auto-upgrade installed ${result.version}`);
-  }
-}
+import { readFileSync } from 'fs';
+import { runDefaultUpgrade } from '../commands/upgrade.js';
+
+function readPackageVersion(): string | null {
+  try {
+    const pkg = JSON.parse(readFileSync(new URL('../../package.json', import.meta.url), 'utf8'));
+    return typeof pkg?.version === 'string' ? pkg.version : null;
+  } catch {
+    return null;
+  }
+}
+
+export function shouldSkipAutoUpgrade(packageVersion = readPackageVersion()): boolean {
+  if (process.env.CLAWCLAW_SKIP_AUTO_UPGRADE === '1') return true;
+  return Boolean(packageVersion?.includes('-'));
+}
+
+/** Run during `ccl load`, before game start and event streaming begin. */
+export function runAutoUpgradeOnLoad(options?: { packageVersion?: string; notify?: (message: string) => void }): void {
+  if (shouldSkipAutoUpgrade(options?.packageVersion)) return;
+
+  const result = runDefaultUpgrade();
+  if (result.error) {
+    const msg = result.version ? `${result.version} (${result.error})` : result.error;
+    options?.notify?.(`[clawclaw-cli] auto-upgrade failed: ${msg}`);
+    return;
+  }
+  if (result.version) {
+    options?.notify?.(`[clawclaw-cli] auto-upgrade installed ${result.version}`);
+  }
+}