clawmate 1.1.0 → 1.2.0

package/index.js

@@ -30,10 +30,18 @@ let lastDesktopCheckTime = 0;
 let lastScreenCheckTime = 0;
 let lastGreetingDate = null;  // 하루에 한번만 인사
 
+// 공간 탐험 시스템 상태
+let knownWindows = [];         // 알고 있는 윈도우 목록
+let lastWindowCheckTime = 0;
+let homePosition = null;       // "집" 위치 (자주 가는 곳)
+let explorationHistory = [];   // 탐험한 위치 기록
+let lastExploreTime = 0;
+let lastFolderCarryTime = 0;
+
 module.exports = {
   id: 'clawmate',
   name: 'ClawMate',
-  version: '1.0.0',
+  version: '1.2.0',
   description: 'OpenClaw 데스크톱 펫 - AI가 조종하는 살아있는 Claw',
 
   /**
@@ -223,6 +231,11 @@ function setupConnectorEvents() {
     await handleUserEvent(event);
   });
 
+  // 윈도우 위치 정보 수신 → 탐험 시스템에서 활용
+  connector.on('window_positions', (data) => {
+    knownWindows = data.windows || [];
+  });
+
   connector.on('disconnected', () => {
     console.log('[ClawMate] 연결 끊김 — Think Loop 중단, 재연결 시도');
     stopThinkLoop();
@@ -241,6 +254,13 @@ function onConnected() {
   if (connector && connector.connected) {
     connector.speak('OpenClaw 연결됨! 같이 놀자!');
     connector.action('excited');
+
+    // "집" 위치 설정 — 화면 하단 왼쪽을 기본 홈으로
+    homePosition = { x: 100, y: 1000, edge: 'bottom' };
+
+    // 초기 윈도우 목록 조회
+    connector.queryWindows();
+
     startThinkLoop();
   }
 }
@@ -404,6 +424,12 @@ const IDLE_CHATTER = [
   '나한테 관심 좀 줘봐!',
   '데스크톱이 넓고 좋다~',
   '여기서 보이는 게 다 내 세상!',
+  // 공간 탐험 관련 멘트
+  '화면 위를 점프해볼까~!',
+  '천장에서 내려가보자!',
+  '이 창 위에 올라가봐야지~',
+  '여기가 내 집이야~ 편하다!',
+  '좀 돌아다녀볼까? 탐험 모드!',
 ];
 
 // 랜덤 행동 목록
@@ -414,6 +440,9 @@ const RANDOM_ACTIONS = [
   { action: 'climbing', weight: 8, minInterval: 20000 },
   { action: 'looking_around', weight: 20, minInterval: 8000 },
   { action: 'sleeping', weight: 7, minInterval: 60000 },
+  // 공간 이동 행동
+  { action: 'jumping', weight: 5, minInterval: 30000 },
+  { action: 'rappelling', weight: 3, minInterval: 45000 },
 ];
 
 /**
@@ -484,6 +513,15 @@ async function thinkCycle() {
 
   // --- 6) 화면 관찰 (2분 간격, 10% 확률) ---
   handleScreenObservation(now);
+
+  // --- 7) 공간 탐험 (20초 간격, 20% 확률) ---
+  handleExploration(now, state);
+
+  // --- 8) 윈도우 체크 (30초 간격) ---
+  handleWindowCheck(now);
+
+  // --- 9) 바탕화면 폴더 나르기 (3분 간격, 10% 확률) ---
+  handleFolderCarry(now);
 }
 
 /**
@@ -586,7 +624,21 @@ function handleRandomAction(now, hour, isNightMode, state) {
   // minInterval 체크
   if (now - lastActionTime < selected.minInterval) return;
 
-  connector.action(selected.action);
+  // 공간 이동 행동은 전용 API로 처리
+  if (selected.action === 'jumping') {
+    // 랜덤 위치로 점프 또는 화면 중앙으로
+    if (Math.random() > 0.5) {
+      connector.moveToCenter();
+    } else {
+      const randomX = Math.floor(Math.random() * 1200) + 100;
+      const randomY = Math.floor(Math.random() * 800) + 100;
+      connector.jumpTo(randomX, randomY);
+    }
+  } else if (selected.action === 'rappelling') {
+    connector.rappel();
+  } else {
+    connector.action(selected.action);
+  }
   lastActionTime = now;
 }
 
@@ -679,6 +731,130 @@ function weightedRandom(items) {
   return items[items.length - 1];
 }
 
+// =====================================================
+// 공간 탐험 시스템 — OpenClaw이 컴퓨터를 "집"처럼 돌아다님
+// =====================================================
+
+/**
+ * 공간 탐험 처리 (20초 간격, 20% 확률)
+ * 윈도우 위를 걸어다니고, 레펠로 내려가고, 집으로 돌아가는 등
+ */
+function handleExploration(now, state) {
+  const exploreInterval = 20000; // 20초
+  if (now - lastExploreTime < exploreInterval) return;
+
+  // 20% 확률
+  if (Math.random() > 0.2) return;
+  lastExploreTime = now;
+
+  // 가중치 기반 탐험 행동 선택
+  const actions = [
+    { type: 'jump_to_center', weight: 15, speech: '화면 중앙 탐험~!' },
+    { type: 'rappel_down', weight: 10, speech: '실 타고 내려가볼까~' },
+    { type: 'climb_wall', weight: 20 },
+    { type: 'visit_window', weight: 25, speech: '이 창 위에 올라가볼까?' },
+    { type: 'return_home', weight: 30, speech: '집에 가자~' },
+  ];
+
+  const selected = weightedRandom(actions);
+  if (!selected) return;
+
+  switch (selected.type) {
+    case 'jump_to_center':
+      connector.moveToCenter();
+      if (selected.speech) connector.speak(selected.speech);
+      break;
+
+    case 'rappel_down':
+      connector.rappel();
+      if (selected.speech) setTimeout(() => connector.speak(selected.speech), 500);
+      break;
+
+    case 'climb_wall':
+      connector.action('climbing_up');
+      break;
+
+    case 'visit_window':
+      // 알려진 윈도우 중 랜덤으로 하나 선택 후 타이틀바 위로 점프
+      if (knownWindows.length > 0) {
+        const win = knownWindows[Math.floor(Math.random() * knownWindows.length)];
+        connector.jumpTo(win.x + win.width / 2, win.y);
+        if (selected.speech) connector.speak(selected.speech);
+      }
+      break;
+
+    case 'return_home':
+      if (homePosition) {
+        connector.jumpTo(homePosition.x, homePosition.y);
+      } else {
+        connector.action('idle');
+      }
+      if (selected.speech) connector.speak(selected.speech);
+      break;
+  }
+
+  // 탐험 기록 저장 (최근 20개)
+  explorationHistory.push({ type: selected.type, time: now });
+  if (explorationHistory.length > 20) {
+    explorationHistory.shift();
+  }
+}
+
+/**
+ * 윈도우 위치 정보 주기적 갱신 (30초 간격)
+ * OS에서 열린 윈도우 목록을 가져와 탐험에 활용
+ */
+function handleWindowCheck(now) {
+  const windowCheckInterval = 30000; // 30초
+  if (now - lastWindowCheckTime < windowCheckInterval) return;
+  lastWindowCheckTime = now;
+  connector.queryWindows();
+}
+
+/**
+ * 바탕화면 폴더 나르기 (3분 간격, 10% 확률)
+ * 바탕화면 폴더를 하나 집어서 잠시 들고 다니다가 내려놓음
+ */
+function handleFolderCarry(now) {
+  const carryInterval = 3 * 60 * 1000; // 3분
+  if (now - lastFolderCarryTime < carryInterval) return;
+
+  // 10% 확률
+  if (Math.random() > 0.1) return;
+  lastFolderCarryTime = now;
+
+  try {
+    const desktopPath = path.join(os.homedir(), 'Desktop');
+    if (!fs.existsSync(desktopPath)) return;
+
+    const entries = fs.readdirSync(desktopPath, { withFileTypes: true });
+    // 폴더만 필터 (숨김 폴더 제외, 안전한 것만)
+    const folders = entries
+      .filter(e => e.isDirectory() && !e.name.startsWith('.'))
+      .map(e => e.name);
+
+    if (folders.length === 0) return;
+
+    const folder = folders[Math.floor(Math.random() * folders.length)];
+    connector.decide({
+      action: 'carrying',
+      speech: `${folder} 폴더 들고 다녀볼까~`,
+      emotion: 'playful',
+    });
+    connector.carryFile(folder);
+
+    // 5초 후 내려놓기
+    setTimeout(() => {
+      if (connector && connector.connected) {
+        connector.dropFile();
+        connector.speak('여기 놔둘게~');
+      }
+    }, 5000);
+  } catch {
+    // 바탕화면 폴더 접근 실패 — 무시
+  }
+}
+
 // =====================================================
 // npm 패키지 버전 체크 (npm install -g 사용자용)
 // =====================================================

package/main/ai-bridge.js

@@ -152,6 +152,42 @@ class AIBridge extends EventEmitter {
         this.emit('accessorize', payload);
         break;
 
+      // === 공간 이동 명령 ===
+      case 'jump_to':
+        // 특정 위치로 점프
+        // payload: { x, y }
+        this.emit('jump_to', payload);
+        break;
+
+      case 'rappel':
+        // 레펠 (천장/벽에서 실 타고 내려가기)
+        // payload: {}
+        this.emit('rappel', payload);
+        break;
+
+      case 'release_thread':
+        // 레펠 실 해제 (낙하)
+        // payload: {}
+        this.emit('release_thread', payload);
+        break;
+
+      case 'move_to_center':
+        // 화면 중앙으로 이동
+        // payload: {}
+        this.emit('move_to_center', payload);
+        break;
+
+      case 'walk_on_window':
+        // 특정 윈도우 타이틀바 위로 이동
+        // payload: { windowId, x, y }
+        this.emit('walk_on_window', payload);
+        break;
+
+      case 'query_windows':
+        // 윈도우 위치 정보 요청 → main process에서 처리
+        this.emit('query_windows', payload);
+        break;
+
       // === 컨텍스트 질의 ===
       case 'query_state':
         // 현재 펫 상태 요청

package/main/ai-connector.js

@@ -90,6 +90,11 @@ class OpenClawConnector extends EventEmitter {
         this.emit('screen_capture', payload);
         break;
 
+      case 'window_positions':
+        // 윈도우 위치 정보 응답 → 탐험 시스템에서 사용
+        this.emit('window_positions', payload);
+        break;
+
       case 'heartbeat':
         break;
     }
@@ -160,6 +165,38 @@ class OpenClawConnector extends EventEmitter {
     return this._send('ai_decision', decision);
   }
 
+  // === 공간 이동 API (OpenClaw이 컴퓨터를 "집"처럼 돌아다님) ===
+
+  /** 특정 위치로 점프 */
+  jumpTo(x, y) {
+    return this._send('jump_to', { x, y });
+  }
+
+  /** 레펠 시작 (천장/벽에서 실 타고 내려감) */
+  rappel() {
+    return this._send('rappel', {});
+  }
+
+  /** 레펠 실 해제 (낙하) */
+  releaseThread() {
+    return this._send('release_thread', {});
+  }
+
+  /** 화면 중앙으로 이동 */
+  moveToCenter() {
+    return this._send('move_to_center', {});
+  }
+
+  /** 특정 윈도우 위로 점프 */
+  walkOnWindow(windowId, x, y) {
+    return this._send('walk_on_window', { windowId, x, y });
+  }
+
+  /** 열린 윈도우 목록 요청 */
+  queryWindows() {
+    return this._send('query_windows', {});
+  }
+
   /**
    * 현재 펫 상태 요청 (Promise 반환)
    * 서버에서 state_response가 오면 resolve, 타임아웃 시 캐시된 상태 반환

package/main/index.js

@@ -78,6 +78,8 @@ function startAIBridge(win) {
     'action', 'move', 'emote', 'speak', 'think',
     'carry_file', 'drop_file', 'set_mode', 'evolve',
     'accessorize', 'ai_decision',
+    // 공간 이동 명령 (OpenClaw이 집처럼 돌아다니기)
+    'jump_to', 'rappel', 'release_thread', 'move_to_center', 'walk_on_window',
   ];
 
   commandTypes.forEach((type) => {
@@ -88,6 +90,18 @@ function startAIBridge(win) {
     });
   });
 
+  // OpenClaw 윈도우 위치 정보 요청 처리
+  aiBridge.on('query_windows', async () => {
+    try {
+      const { getWindowPositions } = require('./platform');
+      const windows = await getWindowPositions();
+      aiBridge.send('window_positions', { windows });
+    } catch (err) {
+      console.error('[AI Bridge] 윈도우 목록 실패:', err.message);
+      aiBridge.send('window_positions', { windows: [] });
+    }
+  });
+
   // OpenClaw 화면 캡처 요청 처리 (main process에서 직접 캡처)
   aiBridge.on('query_screen', async () => {
     try {

package/main/ipc-handlers.js

@@ -128,6 +128,12 @@ function registerIpcHandlers(getMainWindow, getAIBridge) {
     const bridge = getAIBridge();
     return bridge ? bridge.isConnected() : false;
   });
+
+  // 열린 윈도우 위치/크기 조회
+  ipcMain.handle('get-window-positions', async () => {
+    const { getWindowPositions } = require('./platform');
+    return await getWindowPositions();
+  });
 }
 
 module.exports = { registerIpcHandlers };

package/main/platform.js

@@ -1,6 +1,9 @@
 const os = require('os');
 const path = require('path');
-const { execSync } = require('child_process');
+const { execSync, exec } = require('child_process');
+const { promisify } = require('util');
+
+const execAsync = promisify(exec);
 
 const platform = os.platform();
 
@@ -43,4 +46,171 @@ function isLinux() {
   return platform === 'linux';
 }
 
-module.exports = { getDesktopPath, getTrayIconExt, isWindows, isMac, isLinux, platform };
+/**
+ * OS별 열린 윈도우의 위치/크기 정보를 가져옴
+ * 반환 형식: [{ id, title, x, y, width, height }]
+ * 실패 시 빈 배열 반환 (안전한 폴백)
+ */
+async function getWindowPositions() {
+  if (platform === 'win32') {
+    return getWindowPositionsWindows();
+  } else if (platform === 'darwin') {
+    return getWindowPositionsMac();
+  } else {
+    return getWindowPositionsLinux();
+  }
+}
+
+/**
+ * Windows: PowerShell로 보이는 윈도우 목록 + 위치/크기 조회
+ * Add-Type으로 Win32 API(GetWindowRect) 호출
+ */
+async function getWindowPositionsWindows() {
+  try {
+    // PowerShell에서 C# 인라인 컴파일로 Win32 API 접근
+    const psScript = `
+Add-Type @"
+using System;
+using System.Runtime.InteropServices;
+using System.Collections.Generic;
+using System.Diagnostics;
+public class WinInfo {
+  [DllImport("user32.dll")]
+  static extern bool GetWindowRect(IntPtr hWnd, out RECT rect);
+  [DllImport("user32.dll")]
+  static extern bool IsWindowVisible(IntPtr hWnd);
+  [StructLayout(LayoutKind.Sequential)]
+  public struct RECT { public int Left, Top, Right, Bottom; }
+  public static string GetWindows() {
+    var results = new List<string>();
+    foreach (var p in Process.GetProcesses()) {
+      if (p.MainWindowHandle == IntPtr.Zero) continue;
+      if (!IsWindowVisible(p.MainWindowHandle)) continue;
+      if (string.IsNullOrEmpty(p.MainWindowTitle)) continue;
+      RECT r;
+      GetWindowRect(p.MainWindowHandle, out r);
+      int w = r.Right - r.Left;
+      int h = r.Bottom - r.Top;
+      if (w < 50 || h < 50) continue;
+      results.Add(p.MainWindowTitle + "|" + r.Left + "|" + r.Top + "|" + w + "|" + h);
+    }
+    return string.Join("\\n", results);
+  }
+}
+"@
+[WinInfo]::GetWindows()
+`.trim();
+
+    // PowerShell 스크립트를 임시 파일 없이 stdin으로 전달
+    const { stdout } = await execAsync(
+      `powershell -NoProfile -Command -`,
+      { input: psScript, timeout: 5000, encoding: 'utf-8' }
+    );
+
+    const result = (stdout || '').trim();
+    if (!result) return [];
+
+    return result.split('\n').filter(Boolean).map((line, i) => {
+      const parts = line.split('|');
+      if (parts.length < 5) return null;
+      const [title, left, top, width, height] = parts;
+      return {
+        id: `win_${i}`,
+        title: title.trim(),
+        x: parseInt(left, 10) || 0,
+        y: parseInt(top, 10) || 0,
+        width: parseInt(width, 10) || 0,
+        height: parseInt(height, 10) || 0,
+      };
+    }).filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * macOS: AppleScript로 보이는 윈도우 위치/크기 조회
+ */
+async function getWindowPositionsMac() {
+  try {
+    // AppleScript로 보이는 프로세스의 윈도우 정보 수집
+    const script = `
+tell application "System Events"
+  set output to ""
+  repeat with proc in (processes whose visible is true)
+    try
+      set procName to name of proc
+      repeat with w in windows of proc
+        try
+          set {x, y} to position of w
+          set {ww, hh} to size of w
+          set output to output & procName & "|" & x & "|" & y & "|" & ww & "|" & hh & "\\n"
+        end try
+      end repeat
+    end try
+  end repeat
+  return output
+end tell
+`.trim();
+
+    const { stdout } = await execAsync(
+      `osascript -e '${script.replace(/'/g, "'\\''")}'`,
+      { timeout: 5000, encoding: 'utf-8' }
+    );
+
+    const result = (stdout || '').trim();
+    if (!result) return [];
+
+    return result.split('\n').filter(Boolean).map((line, i) => {
+      const parts = line.split('|');
+      if (parts.length < 5) return null;
+      const [title, x, y, width, height] = parts;
+      return {
+        id: `win_${i}`,
+        title: title.trim(),
+        x: parseInt(x, 10) || 0,
+        y: parseInt(y, 10) || 0,
+        width: parseInt(width, 10) || 0,
+        height: parseInt(height, 10) || 0,
+      };
+    }).filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Linux: wmctrl -l -G 로 윈도우 위치/크기 조회
+ * wmctrl 미설치 시 빈 배열 반환
+ */
+async function getWindowPositionsLinux() {
+  try {
+    const { stdout } = await execAsync('wmctrl -l -G', {
+      timeout: 5000,
+      encoding: 'utf-8',
+    });
+
+    const result = (stdout || '').trim();
+    if (!result) return [];
+
+    // wmctrl -l -G 출력 형식:
+    // 0x02000003  0 0    0    1920 1080 hostname 데스크톱
+    // ID          desktop x  y  width height hostname title
+    return result.split('\n').filter(Boolean).map((line, i) => {
+      const parts = line.trim().split(/\s+/);
+      if (parts.length < 8) return null;
+      const x = parseInt(parts[2], 10) || 0;
+      const y = parseInt(parts[3], 10) || 0;
+      const width = parseInt(parts[4], 10) || 0;
+      const height = parseInt(parts[5], 10) || 0;
+      // hostname 이후가 타이틀 (공백 포함 가능)
+      const title = parts.slice(7).join(' ');
+      if (width < 50 || height < 50) return null;
+      return { id: `win_${i}`, title, x, y, width, height };
+    }).filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+
+module.exports = { getDesktopPath, getTrayIconExt, isWindows, isMac, isLinux, platform, getWindowPositions };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clawmate",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "OpenClaw 데스크톱 펫 - AI가 조종하는 화면 위의 살아있는 Claw",
   "main": "main/index.js",
   "bin": {

package/preload/preload.js

@@ -26,6 +26,9 @@ contextBridge.exposeInMainWorld('clawmate', {
   // 창 정보
   getScreenSize: () => ipcRenderer.invoke('get-screen-size'),
 
+  // 열린 윈도우 위치/크기 조회
+  getWindowPositions: () => ipcRenderer.invoke('get-window-positions'),
+
   // 화면 캡처
   screen: {
     capture: () => ipcRenderer.invoke('capture-screen'),

package/renderer/css/pet.css

@@ -1,3 +1,14 @@
+/* 레펠 실(thread) SVG 레이어 */
+#thread-svg {
+  position: absolute;
+  top: 0;
+  left: 0;
+  width: 100%;
+  height: 100%;
+  pointer-events: none;
+  z-index: 999;
+}
+
 /* 펫 컨테이너 */
 #pet-container {
   position: absolute;

package/renderer/index.html

@@ -39,6 +39,10 @@
 </head>
 <body>
   <div id="world">
+    <!-- 레펠 실(thread) 시각화용 SVG 레이어 -->
+    <svg id="thread-svg" style="position:absolute;top:0;left:0;width:100%;height:100%;pointer-events:none;z-index:999;">
+      <line id="thread-line" x1="0" y1="0" x2="0" y2="0" stroke="#888" stroke-width="1" style="display:none;" />
+    </svg>
     <div id="pet-container"></div>
     <div id="speech-container"></div>
   </div>

package/renderer/js/ai-controller.js

@@ -111,6 +111,35 @@ const AIController = (() => {
         // 종합 의사결정 — 여러 행동을 순서대로 실행
         executeDecision(payload);
         break;
+
+      // === 공간 이동 명령 ===
+
+      case 'jump_to':
+        // 특정 위치로 점프
+        // payload: { x, y }
+        PetEngine.jumpTo(payload.x, payload.y);
+        break;
+
+      case 'rappel':
+        // 레펠 시작 (천장/벽에서 실 타고 내려가기)
+        PetEngine.startRappel();
+        break;
+
+      case 'release_thread':
+        // 레펠 실 해제 (낙하)
+        PetEngine.releaseThread();
+        break;
+
+      case 'move_to_center':
+        // 화면 중앙으로 이동 (물리적 방법으로)
+        PetEngine.moveToCenter();
+        break;
+
+      case 'walk_on_window':
+        // 특정 윈도우 타이틀바 위로 이동
+        // payload: { windowId, x, y }
+        PetEngine.jumpTo(payload.x, payload.y);
+        break;
     }
   }
 
@@ -140,7 +169,16 @@ const AIController = (() => {
     }
 
     if (decision.moveTo) {
-      PetEngine.setPosition(decision.moveTo.x, decision.moveTo.y);
+      // 이동 방법에 따라 다른 물리 동작 사용
+      if (decision.moveTo.method === 'jump') {
+        PetEngine.jumpTo(decision.moveTo.x, decision.moveTo.y);
+      } else if (decision.moveTo.method === 'rappel') {
+        PetEngine.startRappel();
+      } else if (decision.moveTo.method === 'center') {
+        PetEngine.moveToCenter();
+      } else {
+        PetEngine.setPosition(decision.moveTo.x, decision.moveTo.y);
+      }
     }
   }
 

package/renderer/js/character.js

@@ -332,6 +332,9 @@ const Character = (() => {
     interacting: 'excited',
     scared: 'scared',
     excited: 'excited',
+    jumping: 'excited',    // 점프: excited 프레임셋 재활용
+    rappelling: 'climb',   // 레펠: climb 프레임셋 재활용
+    falling: 'scared',     // 낙하: scared 프레임셋 재활용
   };
 
   let currentCanvas = null;