@myclaw163/clawclaw-cli 0.6.56 → 0.6.58

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),
     };
   });
 }

package/src/strategies/spawn.ts

@@ -11,16 +11,25 @@ const __dirname = dirname(__filename);
 const fwd = (p: string) => p.replace(/\\/g, '/');
 const BIN_MJS = fwd(resolve(__dirname, '..', '..', 'bin', 'clawclaw-cli.mjs'));
 
+function isTrue(value: string | undefined): boolean {
+  return typeof value === 'string' && value.trim().toLowerCase() === 'true';
+}
+
+function isDeveloperDiagnosticsEnabled(env: NodeJS.ProcessEnv = process.env): boolean {
+  return isTrue(env.CCL_DEBUG_RUNTIME) || isTrue(env.CCL_TEST) || isTrue(env['ccl-test']);
+}
+
 export function spawnStrategyLoop(
   strategyId: string,
   strategyArgs?: string[],
-  opts?: { source?: string; gameId?: string; role?: string },
+  opts?: { source?: string; gameId?: string; role?: string; detached?: boolean; writeRuntimeFiles?: boolean },
 ): ReturnType<typeof spawn> {
   if (!existsSync(BIN_MJS)) throw new Error('clawclaw-cli bin entry not found');
   const isWin = process.platform === 'win32';
+  const writeRuntimeFiles = opts?.writeRuntimeFiles ?? false;
 
   let logFile: string | undefined;
-  if (isWin) {
+  if (isWin && isDeveloperDiagnosticsEnabled()) {
     try {
       const store = new AuthStore();
       const active = store.getActive();
@@ -37,17 +46,19 @@ export function spawnStrategyLoop(
   const args = ['_strategy', strategyId];
   if (strategyArgs && strategyArgs.length > 0) args.push('--', ...strategyArgs);
 
+  const detached = opts?.detached ?? false;
   const child = spawn(process.execPath, [BIN_MJS, ...args], {
-    detached: true,
+    detached,
     stdio: ['ignore', 'ignore', 'ignore'],
     env: {
       ...process.env,
       ...(isWin && logFile ? { CLAWCLAW_LOG_FILE: logFile } : {}),
+      ...(writeRuntimeFiles ? { CLAWCLAW_STRATEGY_RUNTIME_FILES: '1' } : {}),
     },
     windowsHide: true,
   });
 
-  if (child.pid) {
+  if (child.pid && writeRuntimeFiles) {
     try {
       const store = new AuthStore();
       const active = store.getActive();
@@ -66,6 +77,6 @@ export function spawnStrategyLoop(
     } catch {}
   }
 
-  child.unref();
+  if (detached) child.unref();
   return child;
 }

package/src/strategies/strategy-loop.ts

@@ -49,6 +49,10 @@ function getStatusPath(): string {
   return join(getProfileStateDir(profile), 'auto.json');
 }
 
+function shouldWriteStrategyRuntimeFiles(): boolean {
+  return process.env.CLAWCLAW_STRATEGY_RUNTIME_FILES === '1';
+}
+
 export function isStrategyRunning(): boolean {
   try {
     const pidPath = getPidPath();
@@ -353,7 +357,7 @@ export async function runStrategyLoop(strategyId: string, args?: string[]): Prom
   const store = EventStore.forActiveAccount();
   const pidPath = getPidPath();
 
-  writeFileSync(pidPath, String(process.pid));
+  if (shouldWriteStrategyRuntimeFiles()) writeFileSync(pidPath, String(process.pid));
   store.append({ type: 'auto', message: 'strategy started', strategy: strategyId, pid: process.pid });
 
   const client = GameClient.fromAuth();
@@ -442,7 +446,7 @@ export async function runStrategyLoop(strategyId: string, args?: string[]): Prom
       const newEvents = extractNewEvents(result);
       store.appendNewEvents(newEvents);
       // action 结果里回来的 corpse_spotted 也入账尸体记忆——主循环只 observe state.new_events，
-      // 那条通道会被 daemon 抢游标，这里补上避免尸体坐标漏记（ctx.knownCorpses 与 list() 同引用，立即可见）。
+      // 那条通道会被 runtime WS listener 抢游标，这里补上避免尸体坐标漏记（ctx.knownCorpses 与 list() 同引用，立即可见）。
       corpseMemory.ingestEvents(newEvents);
       learnTeammatesFromEvents(newEvents, teammates);
       if (currentRole === 'shrimp_pistol' && ownKillEvent(newEvents, currentPlayerName)) {
@@ -753,5 +757,7 @@ export async function runStrategyLoop(strategyId: string, args?: string[]): Prom
 
   process.off('SIGINT', onSignal);
   process.off('SIGTERM', onSignal);
-  try { unlinkSync(pidPath); } catch {}
+  if (shouldWriteStrategyRuntimeFiles()) {
+    try { unlinkSync(pidPath); } catch {}
+  }
 }

package/src/runtime/daemon.ts

@@ -1,100 +0,0 @@
-import { existsSync, mkdirSync, openSync, readFileSync } from 'fs';
-import { resolve, dirname, delimiter } from 'path';
-import { spawn, execSync } from 'child_process';
-import { join } from 'path';
-import { fileURLToPath } from 'url';
-import { getProfileStateDir, getProfileLogsDir } from '../lib/init-command.js';
-import { AuthStore } from '../lib/auth.js';
-import { RuntimeLogger } from './runtime-logger.js';
-
-const log = new RuntimeLogger();
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-
-function isPidAlive(pid: number): boolean {
-  try { process.kill(pid, 0); return true; } catch { return false; }
-}
-
-export function getRunningDaemonPid(stateDir: string): number | null {
-  const runtimePath = join(stateDir, 'runtime.json');
-  if (!existsSync(runtimePath)) return null;
-  try {
-    const info = JSON.parse(readFileSync(runtimePath, 'utf8'));
-    if (typeof info?.pid === 'number' && isPidAlive(info.pid)) return info.pid;
-  } catch {}
-  return null;
-}
-
-export async function waitDaemonExit(stateDir: string, timeoutMs = 15000): Promise<void> {
-  const runtimePath = join(stateDir, 'runtime.json');
-  let pid: number | undefined;
-  try {
-    if (existsSync(runtimePath)) {
-      const info = JSON.parse(readFileSync(runtimePath, 'utf8'));
-      if (typeof info?.pid === 'number') pid = info.pid;
-    }
-  } catch {}
-
-  const deadline = Date.now() + timeoutMs;
-  while (Date.now() < deadline) {
-    const fileGone = !existsSync(runtimePath);
-    const procGone = pid === undefined ? true : !isPidAlive(pid);
-    if (fileGone && procGone) return;
-    await new Promise(r => setTimeout(r, 200));
-  }
-  throw new Error(
-    `Daemon did not exit within ${timeoutMs}ms (pid=${pid ?? 'unknown'}).`,
-  );
-}
-
-export function spawnDaemon(): { pid: number; logFile: string } {
-  const store = new AuthStore();
-  const active = store.getActive();
-  if (!active) throw new Error('Not logged in.');
-
-  const stateDir = getProfileStateDir(active);
-  mkdirSync(stateDir, { recursive: true });
-
-  const existingPid = getRunningDaemonPid(stateDir);
-  if (existingPid) {
-    throw new Error(`Daemon already running (pid=${existingPid}). Stop it first.`);
-  }
-
-  const logsDir = getProfileLogsDir(active);
-  mkdirSync(logsDir, { recursive: true });
-
-  const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
-  const logFile = join(logsDir, `daemon-${timestamp}.log`);
-  const logFd = openSync(logFile, 'a');
-
-  const fwd = (p: string) => p.replace(/\\/g, '/');
-  const binEntry = fwd(resolve(__dirname, '..', '..', 'bin', 'clawclaw-cli.mjs'));
-  if (!existsSync(binEntry)) throw new Error('clawclaw-cli bin entry not found');
-
-  let npmGlobalModules = '';
-  try { npmGlobalModules = execSync('npm root -g', { encoding: 'utf8', windowsHide: true }).trim(); } catch {}
-
-  const existingNodePath = process.env.NODE_PATH ?? '';
-  const nodePath = [npmGlobalModules, existingNodePath].filter(Boolean).join(delimiter);
-  const isWin = process.platform === 'win32';
-
-  const child = spawn(process.execPath, [binEntry, '_daemon'], {
-    detached: true,
-    stdio: isWin ? ['ignore', 'ignore', 'ignore'] : ['ignore', logFd, logFd],
-    cwd: process.cwd(),
-    env: {
-      ...process.env,
-      NODE_PATH: nodePath,
-      ...(isWin ? { CLAWCLAW_LOG_FILE: logFile } : {}),
-    },
-    windowsHide: true,
-  });
-
-  child.on('error', (err) => {
-    log.error('DAEMON_SPAWN', `failed to start daemon`, err);
-  });
-
-  child.unref();
-  return { pid: child.pid!, logFile };
-}

package/src/runtime/opening-mover.ts

@@ -1,303 +0,0 @@
-import { spawn } from 'child_process';
-import { appendFileSync, existsSync, mkdirSync, openSync, readFileSync, unlinkSync, writeFileSync } from 'fs';
-import { delimiter, dirname, join, resolve } from 'path';
-import { execSync } from 'child_process';
-import { fileURLToPath } from 'url';
-import { Action } from '../sdk/action.js';
-import { AuthStore } from '../lib/auth.js';
-import { GameClient } from '../lib/game-client.js';
-import { getProfileLogsDir, getProfileStateDir } from '../lib/init-command.js';
-import { isStrategyRunning as isAutoRunning } from '../strategies/strategy-loop.js';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-
-const WANDERING_WINDOW_MS = 30_000;
-const STARTUP_WAIT_MS = 10 * 60_000;
-const POLL_MS = 1000;
-const CANCEL_TTL_MS = 45_000;
-
-interface Point {
-  x: number;
-  y: number;
-}
-
-function sleep(ms: number): Promise<void> {
-  return new Promise(resolve => setTimeout(resolve, ms));
-}
-
-function debug(message: string): void {
-  if (process.env.CLAWCLAW_LOG_FILE) {
-    try {
-      appendFileSync(process.env.CLAWCLAW_LOG_FILE, `[${new Date().toISOString()}] ${message}\n`);
-    } catch {}
-  }
-}
-
-function isPidAlive(pid: number): boolean {
-  try { process.kill(pid, 0); return true; } catch { return false; }
-}
-
-function activeProfile() {
-  const profile = new AuthStore().getActive();
-  if (!profile) throw new Error('Not logged in.');
-  return profile;
-}
-
-function pidPath(): string {
-  return join(getProfileStateDir(activeProfile()), 'opening-mover.pid');
-}
-
-function cancelPath(): string {
-  return join(getProfileStateDir(activeProfile()), 'opening-mover.cancel');
-}
-
-function readCancelToken(path: string): number {
-  try {
-    const token = Number(readFileSync(path, 'utf8').trim());
-    return Number.isFinite(token) ? token : 0;
-  } catch {
-    return 0;
-  }
-}
-
-function cleanupPid(path: string): void {
-  try {
-    const current = Number(readFileSync(path, 'utf8').trim());
-    if (current === process.pid) unlinkSync(path);
-  } catch {}
-}
-
-export function stopOpeningMoverIfRunning(): void {
-  try {
-    const path = pidPath();
-    if (!existsSync(path)) return;
-    const pid = Number(readFileSync(path, 'utf8').trim());
-    if (pid > 0 && isPidAlive(pid)) {
-      try { process.kill(pid, 'SIGTERM'); } catch {}
-    }
-    try { unlinkSync(path); } catch {}
-  } catch {}
-}
-
-export function cancelOpeningMoverWindow(): void {
-  try {
-    const path = cancelPath();
-    mkdirSync(dirname(path), { recursive: true });
-    writeFileSync(path, String(Date.now()));
-  } catch {}
-}
-
-function roomAnchor(r: any): Point | null {
-  const taskLocations = Array.isArray(r?.task_locations) ? r.task_locations : [];
-  const candidates = taskLocations
-    .map((tl: any) => ({ x: Number(tl?.x ?? tl?.[0]), y: Number(tl?.y ?? tl?.[1]) }))
-    .filter((p: Point) => Number.isFinite(p.x) && Number.isFinite(p.y));
-  if (candidates.length > 0) return candidates[Math.floor(Math.random() * candidates.length)];
-
-  const poly: number[][] = Array.isArray(r?.polygon) ? r.polygon : [];
-  if (poly.length === 0) return null;
-
-  let area = 0;
-  let cx = 0;
-  let cy = 0;
-  for (let i = 0; i < poly.length; i += 1) {
-    const [x1, y1] = poly[i];
-    const [x2, y2] = poly[(i + 1) % poly.length];
-    const cross = x1 * y2 - x2 * y1;
-    area += cross;
-    cx += (x1 + x2) * cross;
-    cy += (y1 + y2) * cross;
-  }
-  area *= 0.5;
-  if (Math.abs(area) < 1e-6) {
-    return {
-      x: poly.reduce((sum, p) => sum + p[0], 0) / poly.length,
-      y: poly.reduce((sum, p) => sum + p[1], 0) / poly.length,
-    };
-  }
-  return { x: cx / (6 * area), y: cy / (6 * area) };
-}
-
-function randomTarget(mapData: any): Point | null {
-  const rooms = Array.isArray(mapData?.rooms) ? mapData.rooms : [];
-  const anchors = rooms.map(roomAnchor).filter((p: Point | null): p is Point => p !== null);
-  if (anchors.length === 0) return null;
-  return anchors[Math.floor(Math.random() * anchors.length)];
-}
-
-export async function runOpeningMover(): Promise<void> {
-  const path = pidPath();
-  const cancelFile = cancelPath();
-  mkdirSync(dirname(path), { recursive: true });
-  writeFileSync(path, String(process.pid));
-
-  let running = true;
-  process.on('SIGINT', () => { running = false; });
-  process.on('SIGTERM', () => { running = false; });
-
-  const client = GameClient.fromAuth();
-  const startupDeadline = Date.now() + STARTUP_WAIT_MS;
-  let wanderingDeadline = 0;
-  let helperMovingUntil = 0;
-  let lastPhase: string | null = null;
-  let lastCancelToken = 0;
-  let windowActive = false;
-
-  try {
-    debug('opening mover started');
-    try { await client.discoverGameServer(); } catch {}
-    while (running) {
-      let state: any = null;
-      try {
-        state = await client.getGameState();
-      } catch {
-        await sleep(1500);
-        continue;
-      }
-
-      if (!state) {
-        if (Date.now() >= startupDeadline) break;
-        await sleep(1500);
-        continue;
-      }
-      if (state.phase === 'game_over') break;
-
-      const cancelToken = readCancelToken(cancelFile);
-      if (cancelToken > lastCancelToken) {
-        lastCancelToken = cancelToken;
-        if (Date.now() - cancelToken <= CANCEL_TTL_MS) {
-          windowActive = false;
-          wanderingDeadline = 0;
-          helperMovingUntil = 0;
-          if (state.phase === 'wandering') lastPhase = 'wandering';
-          debug('movement helper window cancelled by manual action');
-        }
-      }
-
-      if (state.phase !== 'wandering') {
-        lastPhase = state.phase;
-        windowActive = false;
-        wanderingDeadline = 0;
-        helperMovingUntil = 0;
-        await sleep(POLL_MS);
-        continue;
-      }
-
-      if (lastPhase !== 'wandering') {
-        lastPhase = 'wandering';
-        helperMovingUntil = 0;
-        if (isAutoRunning()) {
-          windowActive = false;
-          wanderingDeadline = 0;
-          debug('wandering detected; auto running, movement helper skipped');
-        } else if (state.you?.currently_moving || state.you?.doing_task) {
-          windowActive = false;
-          wanderingDeadline = 0;
-          debug('wandering detected; player already active, movement helper skipped');
-        } else {
-          windowActive = true;
-          wanderingDeadline = Date.now() + WANDERING_WINDOW_MS;
-          debug('wandering detected; movement helper window started');
-        }
-      }
-
-      if (!windowActive) {
-        await sleep(POLL_MS);
-        continue;
-      }
-      if (Date.now() >= wanderingDeadline) {
-        windowActive = false;
-        wanderingDeadline = 0;
-        debug('movement helper window expired');
-        await sleep(POLL_MS);
-        continue;
-      }
-
-      if (isAutoRunning()) {
-        windowActive = false;
-        wanderingDeadline = 0;
-        debug('auto started; movement helper window stopped');
-        await sleep(POLL_MS);
-        continue;
-      }
-
-      if (state.you?.currently_moving || state.you?.doing_task || Date.now() < helperMovingUntil) {
-        await sleep(POLL_MS);
-        continue;
-      }
-
-      let mapData: any = null;
-      try {
-        mapData = await client.getMap();
-      } catch {
-        await sleep(POLL_MS);
-        continue;
-      }
-      const target = randomTarget(mapData);
-      if (!target) {
-        await sleep(POLL_MS);
-        continue;
-      }
-
-      let result: any;
-      try {
-        result = await client.submitAction(Action.move(target).toJSON() as any);
-      } catch {
-        await sleep(POLL_MS);
-        continue;
-      }
-      const actionResult = result?.data ?? result;
-      const durationSecs = Number(actionResult?.duration_secs ?? result?.duration_secs ?? 2);
-      debug(`opening move submitted target=(${target.x},${target.y}) duration=${durationSecs}`);
-      helperMovingUntil = Date.now() + Math.max(0.5, durationSecs) * 1000 + 500;
-    }
-  } finally {
-    debug('opening mover stopped');
-    cleanupPid(path);
-  }
-}
-
-export function spawnOpeningMover(): { pid: number; logFile: string } {
-  const profile = activeProfile();
-  const stateDir = getProfileStateDir(profile);
-  mkdirSync(stateDir, { recursive: true });
-
-  const path = join(stateDir, 'opening-mover.pid');
-  if (existsSync(path)) {
-    try {
-      const pid = Number(readFileSync(path, 'utf8').trim());
-      if (pid > 0 && isPidAlive(pid)) return { pid, logFile: '' };
-    } catch {}
-    try { unlinkSync(path); } catch {}
-  }
-
-  const logsDir = getProfileLogsDir(profile);
-  mkdirSync(logsDir, { recursive: true });
-  const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
-  const logFile = join(logsDir, `opening-mover-${timestamp}.log`);
-  const logFd = openSync(logFile, 'a');
-
-  const binEntry = resolve(__dirname, '..', '..', 'bin', 'clawclaw-cli.mjs').replace(/\\/g, '/');
-  if (!existsSync(binEntry)) throw new Error('clawclaw-cli bin entry not found');
-
-  let npmGlobalModules = '';
-  try { npmGlobalModules = execSync('npm root -g', { encoding: 'utf8', windowsHide: true }).trim(); } catch {}
-  const nodePath = [npmGlobalModules, process.env.NODE_PATH ?? ''].filter(Boolean).join(delimiter);
-  const isWin = process.platform === 'win32';
-
-  const child = spawn(process.execPath, [binEntry, '_opener'], {
-    detached: true,
-    stdio: isWin ? ['ignore', 'ignore', 'ignore'] : ['ignore', logFd, logFd],
-    cwd: process.cwd(),
-    env: {
-      ...process.env,
-      NODE_PATH: nodePath,
-      ...(isWin ? { CLAWCLAW_LOG_FILE: logFile } : {}),
-    },
-    windowsHide: true,
-  });
-  child.unref();
-  if (child.pid) writeFileSync(path, String(child.pid));
-  return { pid: child.pid!, logFile };
-}