clawmate 1.2.0 → 1.3.0

package/main/tray.js

@@ -1,5 +1,6 @@
-const { Tray, Menu, nativeImage, app } = require('electron');
+const { Tray, Menu, nativeImage, app, shell } = require('electron');
 const path = require('path');
+const { execSync } = require('child_process');
 const Store = require('./store');
 const { undoAllMoves, getFileManifest } = require('./file-ops');
 const { isAutoStartEnabled, toggleAutoStart } = require('./autostart');
@@ -7,28 +8,76 @@ const { isAutoStartEnabled, toggleAutoStart } = require('./autostart');
 let tray = null;
 let aiBridge = null;
 
+/**
+ * 16x16 Claw 픽셀아트 아이콘 생성
+ * 캐릭터 idle 프레임을 축소한 형태
+ *
+ * 색상 코드:
+ *   0 = 투명
+ *   1 = #ff4f40 (빨강)
+ *   2 = #ff775f (연빨강)
+ *   3 = #3a0a0d (갈색 다리)
+ *   4 = #ffffff (눈 흰자)
+ *   5 = #000000 (눈동자)
+ *   6 = #ff4f40 (집게)
+ */
+const CLAW_ICON = [
+  [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],
+  [0,0,6,6,0,0,0,0,0,0,0,0,6,6,0,0],
+  [0,6,0,0,6,0,0,0,0,0,0,6,0,0,6,0],
+  [0,6,0,0,6,0,0,0,0,0,0,6,0,0,6,0],
+  [0,0,6,6,0,0,0,0,0,0,0,0,6,6,0,0],
+  [0,0,0,6,1,1,0,0,0,0,1,1,6,0,0,0],
+  [0,0,0,0,1,1,1,1,1,1,1,1,0,0,0,0],
+  [0,0,0,1,1,4,5,1,1,4,5,1,1,0,0,0],
+  [0,0,0,1,1,4,5,1,1,4,5,1,1,0,0,0],
+  [0,0,1,1,1,1,1,1,1,1,1,1,1,1,0,0],
+  [0,0,1,2,1,1,1,1,1,1,1,1,2,1,0,0],
+  [0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0],
+  [0,0,0,0,1,1,1,1,1,1,1,1,0,0,0,0],
+  [0,0,3,3,3,0,3,3,3,3,0,3,3,3,0,0],
+  [0,3,3,3,0,0,0,3,3,0,0,0,3,3,3,0],
+  [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],
+];
+
+const COLOR_MAP = {
+  0: [0, 0, 0, 0],         // 투명
+  1: [255, 79, 64, 255],    // primary 빨강
+  2: [255, 119, 95, 255],   // secondary 연빨강
+  3: [58, 10, 13, 255],     // dark 갈색
+  4: [255, 255, 255, 255],  // eye 흰자
+  5: [0, 0, 0, 255],        // pupil 눈동자
+  6: [255, 79, 64, 255],    // claw 집게
+};
+
+/**
+ * CLAW_ICON 16x16 배열 → nativeImage 변환
+ */
+function createClawIcon() {
+  const size = 16;
+  const buffer = Buffer.alloc(size * size * 4);
+
+  for (let y = 0; y < size; y++) {
+    for (let x = 0; x < size; x++) {
+      const code = CLAW_ICON[y][x];
+      const color = COLOR_MAP[code] || COLOR_MAP[0];
+      const offset = (y * size + x) * 4;
+      buffer[offset + 0] = color[0]; // R
+      buffer[offset + 1] = color[1]; // G
+      buffer[offset + 2] = color[2]; // B
+      buffer[offset + 3] = color[3]; // A
+    }
+  }
+
+  return nativeImage.createFromBuffer(buffer, { width: size, height: size });
+}
+
 function setupTray(mainWindow, bridge) {
   aiBridge = bridge;
   const store = new Store('clawmate-config', { mode: 'pet' });
 
-  // 트레이 아이콘 생성
-  let icon;
-  try {
-    const iconPath = path.join(__dirname, '..', 'assets', 'icons', 'tray-pet.png');
-    icon = nativeImage.createFromPath(iconPath);
-    if (icon.isEmpty()) throw new Error('no icon');
-  } catch {
-    // 16x16 빨간색 아이콘 폴백
-    const size = 16;
-    const buffer = Buffer.alloc(size * size * 4);
-    for (let i = 0; i < size * size; i++) {
-      buffer[i * 4 + 0] = 0xff;
-      buffer[i * 4 + 1] = 0x4f;
-      buffer[i * 4 + 2] = 0x40;
-      buffer[i * 4 + 3] = 0xff;
-    }
-    icon = nativeImage.createFromBuffer(buffer, { width: size, height: size });
-  }
+  // Claw 픽셀아트 트레이 아이콘 생성
+  const icon = createClawIcon();
 
   tray = new Tray(icon);
   tray.setToolTip('ClawMate - 데스크톱 펫');
@@ -89,6 +138,12 @@ function setupTray(mainWindow, bridge) {
         },
       },
       { type: 'separator' },
+      {
+        label: '업데이트 확인',
+        click: async () => {
+          await checkForUpdateManual(mainWindow);
+        },
+      },
       {
         label: '파일 이동 되돌리기',
         click: async () => {
@@ -122,4 +177,62 @@ function setupTray(mainWindow, bridge) {
   return tray;
 }
 
+/**
+ * 수동 업데이트 확인 (트레이 메뉴에서 클릭)
+ * 빌드된 앱: electron-updater 사용
+ * npm 설치: npm registry에서 최신 버전 비교
+ */
+async function checkForUpdateManual(mainWindow) {
+  if (app.isPackaged) {
+    // electron-updater 기반 업데이트
+    try {
+      const { autoUpdater } = require('electron-updater');
+      autoUpdater.checkForUpdatesAndNotify();
+    } catch (err) {
+      console.error('[업데이트] electron-updater 실패:', err.message);
+    }
+  } else {
+    // npm 기반 업데이트 확인
+    try {
+      const latest = execSync('npm view clawmate version', {
+        encoding: 'utf-8',
+        timeout: 10000,
+      }).trim();
+      const current = require('../package.json').version;
+
+      if (latest !== current) {
+        // 펫 말풍선으로 알림
+        if (mainWindow && !mainWindow.isDestroyed()) {
+          mainWindow.webContents.send('ai-command', {
+            type: 'speak',
+            payload: { text: `새 버전 v${latest} 사용 가능! (현재: v${current})` },
+          });
+        }
+        console.log(`[업데이트] 새 버전 ${latest} 사용 가능 (현재: ${current})`);
+        console.log('[업데이트] npm update -g clawmate');
+
+        // npm 페이지 열기
+        shell.openExternal('https://www.npmjs.com/package/clawmate');
+      } else {
+        // 이미 최신
+        if (mainWindow && !mainWindow.isDestroyed()) {
+          mainWindow.webContents.send('ai-command', {
+            type: 'speak',
+            payload: { text: `v${current} — 이미 최신 버전이야!` },
+          });
+        }
+        console.log(`[업데이트] 현재 최신 버전 (v${current})`);
+      }
+    } catch (err) {
+      console.error('[업데이트] npm 버전 확인 실패:', err.message);
+      if (mainWindow && !mainWindow.isDestroyed()) {
+        mainWindow.webContents.send('ai-command', {
+          type: 'speak',
+          payload: { text: '업데이트 확인 실패... 인터넷 연결 확인해봐!' },
+        });
+      }
+    }
+  }
+}
+
 module.exports = { setupTray };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clawmate",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "description": "OpenClaw 데스크톱 펫 - AI가 조종하는 화면 위의 살아있는 Claw",
   "main": "main/index.js",
   "bin": {
@@ -29,6 +29,7 @@
   "homepage": "https://github.com/boqum/clawmate",
   "dependencies": {
     "electron-updater": "^6.0.0",
+    "node-telegram-bot-api": "^0.66.0",
     "ws": "^8.18.0"
   },
   "devDependencies": {

package/preload/preload.js

@@ -62,4 +62,20 @@ contextBridge.exposeInMainWorld('clawmate', {
 
   // AI 연결 상태 확인
   isAIConnected: () => ipcRenderer.invoke('is-ai-connected'),
+
+  // 메트릭 보고 (렌더러 → main → OpenClaw)
+  reportMetrics: (summary) => ipcRenderer.send('report-metrics', summary),
+
+  // 활성 윈도우 제목 조회 (브라우저 감시)
+  getActiveWindowTitle: () => ipcRenderer.invoke('get-active-window-title'),
+
+  // 커서 위치 조회 (화면 좌표)
+  getCursorPosition: () => ipcRenderer.invoke('get-cursor-position'),
+
+  // === 스마트 파일 조작 ===
+  parseFileCommand: (text) => ipcRenderer.invoke('parse-file-command', text),
+  listFilteredFiles: (sourceDir, filter) => ipcRenderer.invoke('list-filtered-files', sourceDir, filter),
+  smartFileOp: (command) => ipcRenderer.invoke('smart-file-op', command),
+  undoSmartMove: (moveId) => ipcRenderer.invoke('undo-smart-move', moveId),
+  undoAllSmartMoves: () => ipcRenderer.invoke('undo-all-smart-moves'),
 });

package/renderer/index.html

@@ -60,6 +60,8 @@
   <script src="js/time-aware.js"></script>
   <script src="js/mode-manager.js"></script>
   <script src="js/memory.js"></script>
+  <script src="js/metrics.js"></script>
+  <script src="js/browser-watcher.js"></script>
   <script src="js/ai-controller.js"></script>
   <script src="js/app.js"></script>
 </body>

package/renderer/js/ai-controller.js

@@ -140,9 +140,303 @@ const AIController = (() => {
         // payload: { windowId, x, y }
         PetEngine.jumpTo(payload.x, payload.y);
         break;
+
+      // === 커스텀 이동 패턴 ===
+
+      case 'register_movement':
+        // OpenClaw이 JSON으로 이동 패턴 정의를 보내면 등록
+        // payload: { name, definition }
+        // definition: { type, params } — 각 타입별 파라미터
+        _registerAIMovement(payload.name, payload.definition);
+        break;
+
+      case 'custom_move':
+        // 등록된 커스텀 이동 패턴 실행
+        // payload: { name, params? }
+        if (!PetEngine.executeCustomMovement(payload.name, payload.params || {})) {
+          // 실행 실패 시 AI에 알림
+          if (window.clawmate.reportToAI) {
+            window.clawmate.reportToAI('custom_move_failed', {
+              name: payload.name,
+              available: PetEngine.getRegisteredMovements(),
+            });
+          }
+        }
+        break;
+
+      case 'stop_custom_move':
+        // 현재 커스텀 이동 강제 중지
+        PetEngine.stopCustomMovement();
+        break;
+
+      case 'list_movements':
+        // 등록된 이동 패턴 목록 요청
+        if (window.clawmate.reportToAI) {
+          window.clawmate.reportToAI('movement_list', {
+            movements: PetEngine.getRegisteredMovements(),
+          });
+        }
+        break;
+
+      // === 캐릭터 커스터마이징 ===
+      case 'set_character':
+        // AI가 생성한 새 캐릭터 데이터 적용
+        Character.setCharacterData(payload);
+        if (payload.speech) {
+          Speech.show(payload.speech);
+        } else {
+          Speech.show('변신 완료!');
+        }
+        StateMachine.forceState('excited');
+        setTimeout(() => {
+          if (StateMachine.getState() === 'excited') StateMachine.forceState('idle');
+        }, 2000);
+        break;
+
+      case 'reset_character':
+        // 원래 캐릭터로 복원
+        Character.resetCharacter();
+        Speech.show('원래 모습으로 돌아왔어!');
+        StateMachine.forceState('excited');
+        break;
+
+      // === 스마트 파일 조작 애니메이션 ===
+      case 'smart_file_op':
+        handleSmartFileOp(payload);
+        break;
     }
   }
 
+  /**
+   * 스마트 파일 조작 애니메이션 처리
+   *
+   * 텔레그램이나 AI에서 트리거된 파일 이동 작업의
+   * 각 단계(phase)에 따라 펫 애니메이션을 순차 실행.
+   *
+   * phase:
+   *   - start: 작업 시작, 총 파일 수 표시
+   *   - pick_up: 파일 집어들기 (carrying 상태 + 말풍선)
+   *   - drop: 파일 내려놓기 (걷기 상태 + 말풍선)
+   *   - complete: 완료 (excited 상태 + 결과 말풍선)
+   *   - error: 오류 (scared 상태 + 에러 말풍선)
+   */
+  function handleSmartFileOp(payload) {
+    switch (payload.phase) {
+      case 'start':
+        StateMachine.forceState('excited');
+        Speech.show(`${payload.totalFiles}개 파일 정리 시작!`);
+        break;
+
+      case 'pick_up':
+        // 펫이 파일 위치로 이동 (화면 내 랜덤 위치)
+        _smartFileJumpToSource(payload.index);
+        // 집어들기 애니메이션
+        setTimeout(() => {
+          StateMachine.forceState('carrying');
+          Speech.show(`${payload.fileName} 집었다!`);
+        }, 400);
+        break;
+
+      case 'drop':
+        // 대상 폴더 위치로 이동
+        _smartFileJumpToTarget(payload.index);
+        // 내려놓기 애니메이션
+        setTimeout(() => {
+          StateMachine.forceState('walking');
+          Speech.show(`여기! (${payload.targetName})`);
+        }, 400);
+        break;
+
+      case 'complete':
+        StateMachine.forceState('excited');
+        if (payload.movedCount > 0) {
+          Speech.show(`${payload.movedCount}개 파일 옮겼어!`);
+        } else {
+          Speech.show('옮길 파일이 없었어!');
+        }
+        break;
+
+      case 'error':
+        StateMachine.forceState('scared');
+        Speech.show('앗, 뭔가 잘못됐어...');
+        break;
+    }
+  }
+
+  /**
+   * 파일 집어들기 위치로 점프
+   * 파일 인덱스에 따라 화면 좌측 영역의 다른 위치로 이동
+   */
+  function _smartFileJumpToSource(index) {
+    const screenW = window.innerWidth;
+    const screenH = window.innerHeight;
+    // 화면 왼쪽 1/3 영역에서 세로 위치를 파일 인덱스에 따라 분산
+    const targetX = screenW * 0.1 + (index % 3) * 50;
+    const targetY = screenH * 0.3 + ((index * 80) % (screenH * 0.5));
+    PetEngine.jumpTo(targetX, targetY);
+  }
+
+  /**
+   * 파일 내려놓기 위치로 점프
+   * 화면 오른쪽 영역으로 이동
+   */
+  function _smartFileJumpToTarget(index) {
+    const screenW = window.innerWidth;
+    const screenH = window.innerHeight;
+    // 화면 오른쪽 1/3 영역
+    const targetX = screenW * 0.7 + (index % 3) * 50;
+    const targetY = screenH * 0.4 + ((index * 60) % (screenH * 0.4));
+    PetEngine.jumpTo(targetX, targetY);
+  }
+
+  /**
+   * OpenClaw AI가 JSON으로 정의한 이동 패턴을 동적으로 등록
+   * 안전한 실행을 위해 Function 생성자 대신 사전정의된 행동 유형 조합 사용
+   *
+   * definition 형식:
+   * {
+   *   type: 'waypoints' | 'formula' | 'sequence',
+   *   waypoints?: [{x, y, pause?}],          // waypoints 타입
+   *   formula?: { xExpr, yExpr },             // formula 타입 (sin, cos 기반)
+   *   sequence?: ['zigzag', 'shake', ...],    // sequence 타입 (기존 패턴 순차 실행)
+   *   duration?: number,
+   *   speed?: number,
+   * }
+   */
+  function _registerAIMovement(name, definition) {
+    if (!name || !definition || !definition.type) {
+      console.warn('[AIController] 이동 패턴 등록 실패: name, definition.type 필수');
+      return;
+    }
+
+    let handler;
+
+    switch (definition.type) {
+      // 웨이포인트 타입: 지정된 좌표들을 순서대로 이동
+      case 'waypoints':
+        handler = {
+          init(params) {
+            return {
+              waypoints: definition.waypoints || [],
+              currentIdx: 0,
+              speed: definition.speed || 2,
+              pauseTime: 0,
+              pausing: false,
+            };
+          },
+          update(dt, state, ctx) {
+            if (state.currentIdx >= state.waypoints.length) return;
+
+            const wp = state.waypoints[state.currentIdx];
+
+            // 웨이포인트에서 멈춤 중
+            if (state.pausing) {
+              state.pauseTime -= dt;
+              if (state.pauseTime <= 0) {
+                state.pausing = false;
+                state.currentIdx++;
+              }
+              return;
+            }
+
+            const dx = wp.x - ctx.x;
+            const dy = wp.y - ctx.y;
+            const dist = Math.hypot(dx, dy);
+
+            if (dist < 5) {
+              // 웨이포인트 도달
+              if (wp.pause && wp.pause > 0) {
+                state.pausing = true;
+                state.pauseTime = wp.pause;
+              } else {
+                state.currentIdx++;
+              }
+              return;
+            }
+
+            const step = state.speed * (dt / 16);
+            const ratio = Math.min(1, step / dist);
+            ctx.setPos(ctx.x + dx * ratio, ctx.y + dy * ratio);
+            ctx.setFlip(dx < 0);
+          },
+          isComplete(state) {
+            return state.currentIdx >= (state.waypoints || []).length;
+          },
+          cleanup() {},
+        };
+        break;
+
+      // 수식 타입: sin/cos 기반 수학적 궤도
+      case 'formula':
+        handler = {
+          init(params) {
+            return {
+              duration: definition.duration || 3000,
+              elapsed: 0,
+              originX: params.x,
+              originY: params.y,
+              xAmp: definition.formula?.xAmp || 50,
+              yAmp: definition.formula?.yAmp || 30,
+              xFreq: definition.formula?.xFreq || 1,
+              yFreq: definition.formula?.yFreq || 1,
+              xPhase: definition.formula?.xPhase || 0,
+              yPhase: definition.formula?.yPhase || 0,
+            };
+          },
+          update(dt, state, ctx) {
+            state.elapsed += dt;
+            const t = (state.elapsed / state.duration) * Math.PI * 2;
+            const nx = state.originX + Math.sin(t * state.xFreq + state.xPhase) * state.xAmp;
+            const ny = state.originY + Math.sin(t * state.yFreq + state.yPhase) * state.yAmp;
+            ctx.setPos(nx, ny);
+            ctx.setFlip(Math.cos(t * state.xFreq + state.xPhase) < 0);
+          },
+          isComplete(state) {
+            return state.elapsed >= state.duration;
+          },
+          cleanup() {},
+        };
+        break;
+
+      // 시퀀스 타입: 기존 등록된 패턴들을 순차 실행
+      case 'sequence':
+        handler = {
+          init(params) {
+            return {
+              sequence: definition.sequence || [],
+              currentIdx: 0,
+              subStarted: false,
+            };
+          },
+          update(dt, state, ctx) {
+            if (state.currentIdx >= state.sequence.length) return;
+
+            if (!state.subStarted) {
+              const subName = state.sequence[state.currentIdx];
+              // 서브 패턴을 직접 실행하지 않고 상태만 추적
+              PetEngine.executeCustomMovement(subName, {
+                x: ctx.x, y: ctx.y,
+                screenW: ctx.screenW, screenH: ctx.screenH,
+              });
+              state.subStarted = true;
+            }
+          },
+          isComplete(state) {
+            return state.currentIdx >= (state.sequence || []).length;
+          },
+          cleanup() {},
+        };
+        break;
+
+      default:
+        console.warn(`[AIController] 알 수 없는 이동 패턴 타입: ${definition.type}`);
+        return;
+    }
+
+    PetEngine.registerMovement(name, handler);
+    console.log(`[AIController] AI 이동 패턴 등록됨: ${name} (${definition.type})`);
+  }
+
   /**
    * AI 종합 의사결정 실행
    * OpenClaw이 상황을 분석하고 내린 복합적 결정

package/renderer/js/app.js

@@ -71,6 +71,16 @@
   // 시간 인식 초기화 (자율 모드에서만 주도적으로 동작)
   TimeAware.init();
 
+  // 메트릭 수집기 초기화 (선택적 — 없어도 앱 정상 동작)
+  if (typeof Metrics !== 'undefined') {
+    Metrics.init();
+  }
+
+  // 브라우저 감시 초기화 (참견쟁이 모드)
+  if (typeof BrowserWatcher !== 'undefined') {
+    BrowserWatcher.init();
+  }
+
   // 엔진 시작
   PetEngine.start();