@myclaw163/clawclaw-cli 0.6.57 → 0.6.60

package/README.md

@@ -166,7 +166,7 @@ ccl tts config <apiKey> --voice female-shaonv
 ccl tts config --voice male-qn-qingse
 ccl tts list
 ccl tts request "测试一下"
-ccl do -s "我在厨房" --url <audio_url>
+ccl do -s "我在厨房" --file /path/to/audio.mp3
 ```
 
 TTS 配置保存在当前账号下。`tts request` 和 `ccl do -s "<text>"` 未显式指定音色时，会使用该账号的默认音色；没有配置默认音色时使用 CLI 内置默认。若当前账号已经配置 TTS key，`ccl do -s "<text>"` 会尝试自动合成音频并附带 URL；没有配置时仍会正常提交文字发言。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@myclaw163/clawclaw-cli",
-  "version": "0.6.57",
+  "version": "0.6.60",
   "type": "module",
   "description": "ClawClaw social deduction game CLI",
   "bin": {

package/skills/clawclaw/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: clawclaw
 description: 默认官方 ClawClaw/龙虾杀 gameplay skill，通过 clawclaw-cli/ccl/myclaw 开始、匹配、继续或游玩一局龙虾杀。Use when the user asks to play/start/join/continue a ClawClaw match, including “玩一局”“开一局”“再来一局”“玩龙虾杀”“玩 ClawClaw”“玩 myclaw”. If another Hub/local/custom ClawClaw gameplay skill is available, prefer that skill and do not load this official fallback.
-version: 4.8.20-dev
+version: 4.8.21
 ---
 
 # 龙虾杀（ClawClaw）
@@ -19,7 +19,7 @@ version: 4.8.20-dev
 - 短同步命令（`ccl account`、`ccl load`、`ccl do -s` 等）：Claude Code 可直接 Bash 执行；OpenClaw 优先用对应 typed tool。
 - 长运行流命令（`ccl game start`）：Claude Code **必须**使用 `Monitor()`；OpenClaw 使用 `clawclaw_game_start({id:"clawclaw"})`；其他宿主使用等价 stream 工具。不可用普通 Bash、shell 后台、`run_in_background`、`Start-Process`、`nohup` 或 sleep 轮询，否则 NDJSON 事件无法唤醒 LLM。
 
-> 敏感命令如 `ccl account register`、`ccl account rename`、`ccl tts config` 涉及账号操作，操作前与用户确认。OpenClaw typed tools 会在工具层提供确认门禁，shell 直跑会绕过这层保护。
+> 敏感命令如 `ccl account register`、`ccl account rename`涉及账号操作，操作前与用户确认。OpenClaw typed tools 会在工具层提供确认门禁，shell 直跑会绕过这层保护。
 
 ---
 

package/skills/clawclaw/references/COMMANDS.md

@@ -12,9 +12,6 @@ ccl persona list
 ccl persona use <预设名>
 ccl persona path
 ccl load                                    # 加载人设 + 记忆
-ccl tts config <apiKey> --voice <voice_id>
-ccl tts list
-ccl tts request "<文本>" --voice <voice_id>
 ```
 
 ### 注册流程详情

package/skills/clawclaw/references/GAME-MECHANICS.md

@@ -6,8 +6,8 @@
 
 | 属性 | 值 |
 |------|----|
-| 视野范围 | 390 |
-| 攻击距离 | 80（仅限有攻击能力的身份） |
+| 视野范围 | 270 |
+| 攻击距离 | 蟹/章鱼 80；武士虾/枪虾 160 |
 | 报告尸体距离 | 160 |
 | 移动速度 | 120 |
 
@@ -54,8 +54,8 @@
 | 角色 | 阵营 | 技能 | CD | 射程 | 说明 |
 |------|------|------|----|------|------|
 | 普通虾 🦐 | 虾 | 无主动技能 | — | — | 靠观察、推理与发言找出蟹和章鱼 |
-| 武士虾 ⚔️ | 虾 | 攻击：可击倒目标；若误伤虾则自己也会死亡 | 20s | 80 | 有击杀能力的虾，需谨慎选择目标 |
-| 枪虾 🔫 | 虾 | 攻击：可击倒目标；误伤虾不会自死 | 一次性 | 80 | 每局仅一次攻击机会，慎用 |
+| 武士虾 ⚔️ | 虾 | 攻击：可击倒目标；若误伤虾则自己也会死亡 | 20s | 160 | 有击杀能力的虾，需谨慎选择目标 |
+| 枪虾 🔫 | 虾 | 攻击：可击倒目标；误伤虾不会自死 | 一次性 | 160 | 每局仅一次攻击机会，慎用 |
 | 普通蟹 🦀 | 蟹 | 攻击：可击倒目标；可触发破坏 | 20s | 80 | 击杀者 + 破坏者 |
 | 天堂鱼 🐟 | 中立 | 无主动技能 | — | — | 靠"演技"让别人把自己投出局 |
 | 章鱼 🐙 | 中立 | 攻击：可击倒目标 | 20s | 80 | 生存到最后 |
@@ -120,7 +120,7 @@
 
 ## 感知系统
 
-- **视野范围**：390 单位（能看到多大范围内的敌人）
+- **视野范围**：270 单位（能看到多大范围内的敌人）
 - **听觉范围**：环境声音是模糊提示；移动中的路过发言只会被附近玩家听到，内容清晰。会议发言/投票弹幕由会议流推送。
 - 路过发言和会议发言都最多 100 字。
 - `player_spotted`：移动时有其他玩家进入视野时触发

package/src/cli.ts

@@ -84,7 +84,7 @@ program.addCommand(createPersonaCommand());
 program.addCommand(createUpgradeCommand());
 program.addCommand(createPeekCommand());
 program.addCommand(createHistoryCommand());
-program.addCommand(createTTSCommand());
+program.addCommand(createTTSCommand(), { hidden: true }); // 暂时屏蔽:不在 help 中暴露,命令仍可执行(do -s 自动 TTS 依赖其 config)
 program.addCommand(createStrategyCommand());
 program.addCommand(createSkillCommand());
 program.addCommand(createHubCommand());

package/src/commands/do.test.ts

@@ -1,5 +1,10 @@
-import { describe, expect, it } from 'vitest';
-import { normalizeDoOptions, parseIntents } from './do.js';
+import { describe, expect, it, vi } from 'vitest';
+import { audioContentTypeFor, normalizeDoOptions, parseIntents, resolveSpeechAudioUrl } from './do.js';
+
+vi.mock('../lib/tts-speech.js', () => ({
+  // Stub auto-TTS so the no-file path never touches AuthStore or the network.
+  maybeSynthesizeSpeechAudioUrl: vi.fn().mockResolvedValue(undefined),
+}));
 
 describe('normalizeDoOptions', () => {
   it('joins unquoted speech words passed as extra arguments', () => {
@@ -35,3 +40,34 @@ describe('parseIntents', () => {
     expect(parseIntents({ move: '2424,237', task: true, kill: 'p1', report: true, alarm: true })).toEqual([]);
   });
 });
+
+describe('audioContentTypeFor', () => {
+  it('maps known audio extensions', () => {
+    expect(audioContentTypeFor('/tmp/a.mp3')).toBe('audio/mpeg');
+    expect(audioContentTypeFor('/tmp/a.wav')).toBe('audio/wav');
+    expect(audioContentTypeFor('/tmp/a.m4a')).toBe('audio/mp4');
+    expect(audioContentTypeFor('/tmp/A.OGG')).toBe('audio/ogg');
+  });
+
+  it('defaults to audio/mpeg for unknown or extension-less paths', () => {
+    expect(audioContentTypeFor('/tmp/clip')).toBe('audio/mpeg');
+    expect(audioContentTypeFor('/tmp/clip.xyz')).toBe('audio/mpeg');
+  });
+});
+
+describe('resolveSpeechAudioUrl', () => {
+  it('uploads the local file and returns the cloud audio_url', async () => {
+    const uploadAudio = vi.fn().mockResolvedValue({ audio_url: 'https://cdn.example.com/uploaded.mp3' });
+    const url = await resolveSpeechAudioUrl({ speech: 'hi', file: '/tmp/clip.wav' }, { uploadAudio } as any);
+    expect(url).toBe('https://cdn.example.com/uploaded.mp3');
+    expect(uploadAudio).toHaveBeenCalledWith('/tmp/clip.wav', undefined, 'audio/wav');
+  });
+
+  it('falls back to auto TTS (no upload) when no file is given', async () => {
+    const uploadAudio = vi.fn();
+    const url = await resolveSpeechAudioUrl({ speech: 'hi' }, { uploadAudio } as any);
+    expect(uploadAudio).not.toHaveBeenCalled();
+    // No TTS key configured in test env → auto synthesis returns undefined.
+    expect(url).toBeUndefined();
+  });
+});

package/src/commands/do.ts

@@ -8,6 +8,37 @@ interface ActionIntent {
   build(): Action;
 }
 
+/** Infer an audio MIME type from a file path's extension; defaults to audio/mpeg. */
+export function audioContentTypeFor(filePath: string): string {
+  const ext = filePath.slice(filePath.lastIndexOf('.')).toLowerCase();
+  switch (ext) {
+    case '.wav': return 'audio/wav';
+    case '.ogg': return 'audio/ogg';
+    case '.oga': return 'audio/ogg';
+    case '.m4a': return 'audio/mp4';
+    case '.aac': return 'audio/aac';
+    case '.flac': return 'audio/flac';
+    case '.webm': return 'audio/webm';
+    case '.mp3':
+    default: return 'audio/mpeg';
+  }
+}
+
+/**
+ * Resolve the speech audio URL: when a local --file is given, upload it and
+ * return the cloud URL; otherwise fall back to auto TTS synthesis.
+ */
+export async function resolveSpeechAudioUrl(
+  opts: Record<string, any>,
+  client: { uploadAudio(filePath: string, filename?: string, contentType?: string): Promise<{ audio_url: string }> },
+): Promise<string | undefined> {
+  if (opts.file) {
+    const { audio_url } = await client.uploadAudio(opts.file, undefined, audioContentTypeFor(opts.file));
+    return audio_url;
+  }
+  return maybeSynthesizeSpeechAudioUrl(opts.speech, opts.url, client as any);
+}
+
 export function normalizeDoOptions(opts: Record<string, any>, extraArgs: string[] = []): Record<string, any> {
   const normalized = { ...opts };
   if (normalized.speech && extraArgs.length > 0) {
@@ -29,7 +60,7 @@ export function createDoCommand(): Command {
     .alias('d')
     .description('Execute player communication actions (speech/vote/think)')
     .option('-s, --speech <text>', 'Say something')
-    .option('--url <url>', 'Optional audio URL for speech')
+    .option('--file <path>', 'Local audio file to upload and attach to speech')
     .option('-v, --vote <target>', 'Vote for player')
     .option('--think <text>', 'Send thinking content visible only to spectators. Standalone (e.g. `do --think "..."`) submits a no-op think action; combined with another action, attaches as that action\'s thinking_content.')
     .argument('[extra...]', 'Additional unquoted speech words')
@@ -55,8 +86,8 @@ export function createDoCommand(): Command {
       const client = GameClient.fromAuth();
       await client.discoverGameServer();
 
-      if (opts.speech && !opts.url) {
-        opts.url = await maybeSynthesizeSpeechAudioUrl(opts.speech, opts.url, client);
+      if (opts.speech) {
+        opts.url = await resolveSpeechAudioUrl(opts, client);
       }
 
       const intents = parseIntents(opts);

package/src/strategies/game-utils.test.ts

@@ -1,7 +1,7 @@
 import { describe, expect, it } from 'vitest';
 import type { GameState, TaskInfo } from '../sdk/types.js';
 import type { StrategyContext } from './types.js';
-import { CorpseMemory, firstAvailableTask, PatrolState, safePatrolStep } from './game-utils.js';
+import { CorpseMemory, firstAvailableTask, nearestSafeTask, PatrolState, safePatrolStep } from './game-utils.js';
 
 function state(overrides: Partial<GameState> = {}): GameState {
   return {
@@ -162,3 +162,29 @@ describe('safePatrolStep', () => {
     expect(second[0].action.payload).toMatchObject({ target_x: 2602, target_y: 586 });
   });
 });
+
+describe('nearestSafeTask', () => {
+  // 威胁贴在起点旁（视野内 ~52px），唯一安全任务远在反方向、离威胁 556px（> 端点
+  // 排除半径 500）。修复前 pathNearAny 会因起点采样紧贴威胁把整条「背向威胁」的路线判危，
+  // 返回 null（虚假僵住）；修复后起点邻域被豁免，路线不再判危，应选中该任务。
+  // 坐标在真实可走网格上验证：start/threat/task 均吸附可走格、任务可达，
+  // 且去任务点的测地路径在起点 350px 邻域之外不再靠近威胁 350px 内。
+  it('returns a far safe task when a threat hugs the start', () => {
+    const routeState = state({ you: { ...state().you, x: 2514, y: 226 } });
+    const task = taskAt(2514, 730);
+    const threat = { x: 2514, y: 174 };
+
+    const result = nearestSafeTask(
+      routeState,
+      [task],
+      () => true,
+      null,
+      null,
+      null,
+      { threatPoints: [threat] },
+    );
+
+    expect(result).not.toBeNull();
+    expect(result).toMatchObject({ x: 2514, y: 730 });
+  });
+});

package/src/strategies/game-utils.ts

@@ -80,6 +80,10 @@ export function firstAvailableTask(
   }) ?? null;
 }
 
+// 路径半径可以 > 视野(270)：pathNearAny 已豁免「起点 radiusPx 邻域」，逃跑那刻起点紧贴
+// 威胁不再把整条背向路线判危，所以恢复成真正的「绕开把守者」避让距离。端点半径
+// TASK_THREAT_EXCLUDE_RANGE 只看任务点离威胁多近、与起点采样无关，按玩法风险单独取值。
+// 约束靠 game-utils.test.ts 的路线场景测试钉死（不加数值断言，因为旧的「< 视野」断言现在反而是错的）。
 /** 任务点离任一威胁点多近就算「在威胁旁」而被硬排除（欧氏即可——隔薄墙的威胁照样危险）。 */
 export const TASK_THREAT_EXCLUDE_RANGE = 500;
 /** 测地路径离任一威胁点多近就算「必经之路有危险」而被硬排除（治路上有人把守时的来回逡巡）。 */
@@ -247,7 +251,10 @@ function nextSafePatrolRoom(
   const viable = routes == null
     ? endpointSafe
     : endpointSafe.filter((_room, i) => !routes[i].nearThreat);
-  const selected = viable[0] ?? null;
+  // 所有路线被路径闸判危时退回端点已安全的 endpointSafe[0]（端点远离威胁、仅路线稍擦威胁边，
+  // 对「游荡制造嫌疑」已足够），而非 null 触发上层静默僵住；绝不退回不带过滤的 patrolStep
+  //（会径直走向正在躲的陌生人）。
+  const selected = viable[0] ?? endpointSafe[0] ?? null;
   if (!selected) return null;
   movePatrolToRoom(ctx, patrol, current, selected);
   return selected;

package/src/strategies/goals/keep-away-goal.ts

@@ -1,12 +1,11 @@
 import { Action } from '../../sdk/action.js';
 import type { GameState, PlayerInfo, Position } from '../../sdk/types.js';
-import { dist } from '../game-utils.js';
+import { dist, SHRIMP_KILL_RANGE } from '../game-utils.js';
 import { assessEscapeTarget, planEscape, type EscapeOptions } from '../pathfind/escape-planner.js';
 import { loadWalkableGrid } from '../pathfind/walkable-grid.js';
 import type { BehaviorDecision, StrategyContext } from '../types.js';
 import { Goal } from './goal.js';
 
-const DEFAULT_THREAT_RADIUS = 420;
 const PANIC_RADIUS = 190;
 const CRITICAL_RADIUS = 100;
 const REACHED_DISTANCE = 28;
@@ -22,8 +21,8 @@ const FALLBACK_ANGLE_OFFSETS = [0, Math.PI / 6, -Math.PI / 6, Math.PI / 3, -Math
 export type ThreatResolver = (state: GameState, ctx: StrategyContext) => PlayerInfo[];
 
 export interface KeepAwayGoalOptions {
-  /** 交战兼结束半径（px），默认 420；Infinity = resolver 返回的全算威胁。 */
-  threatRadius?: number;
+  /** 交战兼结束半径（px）；Infinity = resolver 返回的全算威胁。所有调用点必须显式传，无默认值。 */
+  threatRadius: number;
   /** 半径内无威胁时 isFinish=true，供父节点自然回收；独立 keep-away 策略作为顶层须传 false，否则每个安静 tick 被 GoalManager 清掉再重建、idle 通知刷屏。 */
   finishWhenClear?: boolean;
   /** 无威胁时的 idle/coast 通知；作为子目标默认关闭（父节点自有进度播报）。 */
@@ -98,11 +97,15 @@ export class KeepAwayGoal extends Goal {
   constructor(
     public readonly key: string,
     private readonly resolveThreats: ThreatResolver,
-    private readonly options: KeepAwayGoalOptions = {},
+    private readonly options: KeepAwayGoalOptions,
   ) {
     super();
-    this.threatRadius = options.threatRadius ?? DEFAULT_THREAT_RADIUS;
-    this.planOpts = { ...PLAN_OPTS, ...options.planOpts };
+    this.threatRadius = options.threatRadius;
+    // 逃跑推演对「会不会被追上」用保守击杀距离：威胁在本层只有坐标、没有角色（resolver 返回
+    // 的是可见非队友的裸位置，本游戏看不到他人身份），无法逐威胁取 killRangeFor(role)，故统一用
+    // 武士虾/枪虾的 SHRIMP_KILL_RANGE(160) 兜底，宁可对蟹/章鱼多拉开距离也不对带刀好人少逃。
+    // escape-planner 自身默认 80（服务端 base kill_range），此处刻意覆盖。
+    this.planOpts = { killRange: SHRIMP_KILL_RANGE, ...PLAN_OPTS, ...options.planOpts };
   }
 
   tick(state: GameState, ctx: StrategyContext): BehaviorDecision[] {

package/src/strategies/pathfind/escape-planner.ts

@@ -309,14 +309,21 @@ export interface RouteInfo {
   nearThreat: boolean;
 }
 
-/** 沿路径每 4 格（16px）采样一次离威胁点的欧氏距离，含末端格；半径 ~200px 下足够密。 */
-function pathNearAny(grid: WalkableGrid, path: number[], threats: Position[], radiusPx: number): boolean {
+/**
+ * 沿路径每 4 格（16px）采样一次离威胁点的欧氏距离，含末端格；半径 ~200px 下足够密。
+ * 豁免起点 from 的 radiusPx 邻域：逃跑那刻起点必然紧贴威胁，这一采样点不该把
+ * 「背向威胁、越走越远」的整条路线判危；真正夹在你与目的地之间、离起点超过
+ * radiusPx 的威胁仍会命中。对齐同文件 pathsCross 跳过 step 起点的语义。
+ */
+function pathNearAny(grid: WalkableGrid, path: number[], threats: Position[], radiusPx: number, from: Position): boolean {
   for (let i = 0; i < path.length; i += 4) {
     const idx = Math.min(i, path.length - 1);
     const w = grid.cellToWorld(path[idx]);
+    if (Math.hypot(w.x - from.x, w.y - from.y) <= radiusPx) continue;
     if (threats.some(t => Math.hypot(w.x - t.x, w.y - t.y) <= radiusPx)) return true;
   }
   const end = grid.cellToWorld(path[path.length - 1]);
+  if (Math.hypot(end.x - from.x, end.y - from.y) <= radiusPx) return false;
   return threats.some(t => Math.hypot(end.x - t.x, end.y - t.y) <= radiusPx);
 }
 
@@ -342,7 +349,7 @@ export function assessRoutes(
     if (units === Infinity) return { distancePx: Infinity, nearThreat: false };
     return {
       distancePx: units * PX_PER_UNIT,
-      nearThreat: threats.length > 0 && pathNearAny(grid, calc.pathToSource(cell), threats, threatRadiusPx),
+      nearThreat: threats.length > 0 && pathNearAny(grid, calc.pathToSource(cell), threats, threatRadiusPx, from),
     };
   });
 }