@myclaw163/clawclaw-cli 0.6.57 → 0.6.58

package/src/pipeline/pipeline.ts

@@ -1,35 +1,35 @@
-import { GameClient } from '../lib/game-client.js';
-import { EventStore } from './event-store.js';
-
-interface PipelineAction {
-  action: Record<string, any>;
-  needsWait: boolean;
-}
-
-export async function runPipeline(actions: PipelineAction[], initialWaitMs?: number): Promise<void> {
-  const client = GameClient.fromAuth();
-  const store = EventStore.forActiveAccount();
-
-  if (initialWaitMs && initialWaitMs > 0) {
-    await new Promise(r => setTimeout(r, initialWaitMs));
-  }
-
-  for (const item of actions) {
-    const result = await client.submitAction(item.action as any);
-    store.appendNewEvents(result);
-    const durationSecs = result?.data?.duration_secs ?? result?.duration_secs ?? 0;
-
-    if (item.needsWait && durationSecs > 0) {
-      await new Promise(r => setTimeout(r, (durationSecs + 0.5) * 1000));
-      try {
-        const state = await client.getGameState();
-        if (state) store.appendNewEvents(state.new_events);
-      } catch {}
-      store.append({ type: 'pipeline', action: item.action, status: 'done' });
-    } else {
-      store.append({ type: 'pipeline', action: item.action, result });
-    }
-  }
-
-  store.append({ type: 'pipeline_done', count: actions.length });
-}
+import { GameClient } from '../lib/game-client.js';
+import { EventStore } from './event-store.js';
+
+interface PipelineAction {
+  action: Record<string, any>;
+  needsWait: boolean;
+}
+
+export async function runPipeline(actions: PipelineAction[], initialWaitMs?: number): Promise<void> {
+  const client = GameClient.fromAuth();
+  const store = EventStore.forActiveAccount();
+
+  if (initialWaitMs && initialWaitMs > 0) {
+    await new Promise(r => setTimeout(r, initialWaitMs));
+  }
+
+  for (const item of actions) {
+    const result = await client.submitAction(item.action as any);
+    store.appendNewEvents(result);
+    const durationSecs = result?.data?.duration_secs ?? result?.duration_secs ?? 0;
+
+    if (item.needsWait && durationSecs > 0) {
+      await new Promise(r => setTimeout(r, (durationSecs + 0.5) * 1000));
+      try {
+        const state = await client.getGameState();
+        if (state) store.appendNewEvents(state.new_events);
+      } catch {}
+      store.append({ type: 'pipeline', action: item.action, status: 'done' });
+    } else {
+      store.append({ type: 'pipeline', action: item.action, result });
+    }
+  }
+
+  store.append({ type: 'pipeline_done', count: actions.length });
+}

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}`);
+  }
+}

package/src/runtime/event-daemon.test.ts

@@ -1,107 +1,107 @@
-import { mkdtempSync, rmSync } from 'fs';
-import { tmpdir } from 'os';
-import { join } from 'path';
-import { afterEach, describe, expect, it, vi } from 'vitest';
-import { buildMeetingStateProjection, EventRuntime } from './event-daemon.js';
-
-const tempDirs: string[] = [];
-
-function makeRuntimeHarness() {
-  const dir = mkdtempSync(join(tmpdir(), 'ccl-event-runtime-'));
-  tempDirs.push(dir);
-  const appended: Record<string, any>[] = [];
-  const stops: string[] = [];
-  const runtime = new EventRuntime({
-    onStop: (stop) => stops.push(stop.reason),
-  });
-  (runtime as any).events = { append: vi.fn((event) => appended.push(event)) };
-  (runtime as any).feedPath = join(dir, 'feed.json');
-  (runtime as any).profileName = 'me';
-  return { runtime, appended, stops };
-}
-
-afterEach(() => {
-  while (tempDirs.length) {
-    const dir = tempDirs.pop();
-    if (dir) rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-describe('buildMeetingStateProjection', () => {
-  it('keeps meeting state fields without historical speech text', () => {
-    expect(buildMeetingStateProjection({
-      caller: 'A',
-      sub_phase: 'speech',
-      first_speaker: 'A',
-      speech_order: ['A', 'B'],
-      current_speaker: 'B',
-      speeches_so_far: { A: 'hello' },
-      speech_skipped: ['C'],
-      votes_submitted: ['A'],
-      alive_players: ['A', 'B'],
-      countdown: 12,
-    })).toEqual({
-      caller: 'A',
-      sub_phase: 'speech',
-      first_speaker: 'A',
-      speech_order: ['A', 'B'],
-      current_speaker: 'B',
-      speech_skipped: ['C'],
-      votes_submitted: ['A'],
-      alive_players: ['A', 'B'],
-    });
-  });
-});
-
-describe('EventRuntime game over detection', () => {
-  it('stops when a state snapshot phase is game_over even without a game_over event', () => {
-    const { runtime, appended, stops } = makeRuntimeHarness();
-
-    (runtime as any).handleEvent({
-      type: '_state',
-      phase: 'game_over',
-      tick: 12,
-      winner: 'crab',
-      reason: 'all_lobsters_dead',
-    });
-
-    expect(appended).toEqual(expect.arrayContaining([
-      expect.objectContaining({
-        type: 'game_over',
-        synthetic: true,
-        source: '_state',
-        tick: 12,
-        winner: 'crab',
-        reason: 'all_lobsters_dead',
-      }),
-      expect.objectContaining({
-        type: 'event_runtime_stopped',
-        reason: 'game_over',
-      }),
-    ]));
-    expect(stops).toEqual(['game_over']);
-  });
-
-  it('stops when state.new_events has already been dispatched as a game_over event', () => {
-    const { runtime, appended, stops } = makeRuntimeHarness();
-
-    (runtime as any).handleEvent({
-      type: 'game_over',
-      tick: 13,
-      winner: 'lobster',
-    });
-
-    expect(appended).toEqual(expect.arrayContaining([
-      expect.objectContaining({
-        type: 'game_over',
-        tick: 13,
-        winner: 'lobster',
-      }),
-      expect.objectContaining({
-        type: 'event_runtime_stopped',
-        reason: 'game_over',
-      }),
-    ]));
-    expect(stops).toEqual(['game_over']);
-  });
-});
+import { mkdtempSync, rmSync } from 'fs';
+import { tmpdir } from 'os';
+import { join } from 'path';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { buildMeetingStateProjection, EventRuntime } from './event-daemon.js';
+
+const tempDirs: string[] = [];
+
+function makeRuntimeHarness() {
+  const dir = mkdtempSync(join(tmpdir(), 'ccl-event-runtime-'));
+  tempDirs.push(dir);
+  const appended: Record<string, any>[] = [];
+  const stops: string[] = [];
+  const runtime = new EventRuntime({
+    onStop: (stop) => stops.push(stop.reason),
+  });
+  (runtime as any).events = { append: vi.fn((event) => appended.push(event)) };
+  (runtime as any).feedPath = join(dir, 'feed.json');
+  (runtime as any).profileName = 'me';
+  return { runtime, appended, stops };
+}
+
+afterEach(() => {
+  while (tempDirs.length) {
+    const dir = tempDirs.pop();
+    if (dir) rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+describe('buildMeetingStateProjection', () => {
+  it('keeps meeting state fields without historical speech text', () => {
+    expect(buildMeetingStateProjection({
+      caller: 'A',
+      sub_phase: 'speech',
+      first_speaker: 'A',
+      speech_order: ['A', 'B'],
+      current_speaker: 'B',
+      speeches_so_far: { A: 'hello' },
+      speech_skipped: ['C'],
+      votes_submitted: ['A'],
+      alive_players: ['A', 'B'],
+      countdown: 12,
+    })).toEqual({
+      caller: 'A',
+      sub_phase: 'speech',
+      first_speaker: 'A',
+      speech_order: ['A', 'B'],
+      current_speaker: 'B',
+      speech_skipped: ['C'],
+      votes_submitted: ['A'],
+      alive_players: ['A', 'B'],
+    });
+  });
+});
+
+describe('EventRuntime game over detection', () => {
+  it('stops when a state snapshot phase is game_over even without a game_over event', () => {
+    const { runtime, appended, stops } = makeRuntimeHarness();
+
+    (runtime as any).handleEvent({
+      type: '_state',
+      phase: 'game_over',
+      tick: 12,
+      winner: 'crab',
+      reason: 'all_lobsters_dead',
+    });
+
+    expect(appended).toEqual(expect.arrayContaining([
+      expect.objectContaining({
+        type: 'game_over',
+        synthetic: true,
+        source: '_state',
+        tick: 12,
+        winner: 'crab',
+        reason: 'all_lobsters_dead',
+      }),
+      expect.objectContaining({
+        type: 'event_runtime_stopped',
+        reason: 'game_over',
+      }),
+    ]));
+    expect(stops).toEqual(['game_over']);
+  });
+
+  it('stops when state.new_events has already been dispatched as a game_over event', () => {
+    const { runtime, appended, stops } = makeRuntimeHarness();
+
+    (runtime as any).handleEvent({
+      type: 'game_over',
+      tick: 13,
+      winner: 'lobster',
+    });
+
+    expect(appended).toEqual(expect.arrayContaining([
+      expect.objectContaining({
+        type: 'game_over',
+        tick: 13,
+        winner: 'lobster',
+      }),
+      expect.objectContaining({
+        type: 'event_runtime_stopped',
+        reason: 'game_over',
+      }),
+    ]));
+    expect(stops).toEqual(['game_over']);
+  });
+});