clawmate 1.0.0

package/main/ai-connector.js

@@ -0,0 +1,169 @@
+/**
+ * OpenClaw 에이전트 측 커넥터
+ *
+ * OpenClaw이 ClawMate에 접속해서 펫을 조종하는 클라이언트.
+ * OpenClaw 플러그인(index.js)에서 사용됨.
+ *
+ * 사용 예:
+ *   const connector = new OpenClawConnector();
+ *   await connector.connect();
+ *   connector.speak('안녕! 오늘 뭐 할 거야?');
+ *   connector.action('excited');
+ *   connector.onUserEvent((event) => { ... AI가 반응 결정 ... });
+ */
+const WebSocket = require('ws');
+const EventEmitter = require('events');
+
+class OpenClawConnector extends EventEmitter {
+  constructor(port = 9320) {
+    super();
+    this.port = port;
+    this.ws = null;
+    this.connected = false;
+    this.petState = null;
+    this._reconnectTimer = null;
+    this._autoReconnect = true;
+  }
+
+  /**
+   * ClawMate에 접속
+   */
+  connect() {
+    return new Promise((resolve, reject) => {
+      try {
+        this.ws = new WebSocket(`ws://127.0.0.1:${this.port}`);
+
+        this.ws.on('open', () => {
+          this.connected = true;
+          this.emit('connected');
+          resolve();
+        });
+
+        this.ws.on('message', (data) => {
+          try {
+            const msg = JSON.parse(data.toString());
+            this._handleMessage(msg);
+          } catch {}
+        });
+
+        this.ws.on('close', () => {
+          this.connected = false;
+          this.emit('disconnected');
+          if (this._autoReconnect) {
+            this._reconnectTimer = setTimeout(() => this.connect().catch(() => {}), 5000);
+          }
+        });
+
+        this.ws.on('error', (err) => {
+          if (!this.connected) reject(err);
+        });
+      } catch (err) {
+        reject(err);
+      }
+    });
+  }
+
+  _handleMessage(msg) {
+    const { type, payload } = msg;
+
+    switch (type) {
+      case 'sync':
+      case 'state_response':
+      case 'pet_state_update':
+        this.petState = payload;
+        this.emit('state_update', payload);
+        break;
+
+      case 'user_event':
+        // 사용자 이벤트 → OpenClaw AI가 반응 결정
+        this.emit('user_event', payload);
+        break;
+
+      case 'heartbeat':
+        break;
+    }
+  }
+
+  _send(type, payload) {
+    if (!this.ws || !this.connected) return false;
+    try {
+      this.ws.send(JSON.stringify({ type, payload }));
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  // === OpenClaw → ClawMate 명령 API ===
+
+  /** 펫이 말하게 함 */
+  speak(text, style = 'normal') {
+    return this._send('speak', { text, style });
+  }
+
+  /** 펫이 생각하게 함 (말풍선에 ...) */
+  think(text) {
+    return this._send('think', { text });
+  }
+
+  /** 펫 행동 변경 */
+  action(state, duration) {
+    return this._send('action', { state, duration });
+  }
+
+  /** 특정 위치로 이동 */
+  moveTo(x, y, speed) {
+    return this._send('move', { x, y, speed });
+  }
+
+  /** 감정 표현 */
+  emote(emotion) {
+    return this._send('emote', { emotion });
+  }
+
+  /** 파일 집어들기 */
+  carryFile(fileName, targetX) {
+    return this._send('carry_file', { fileName, targetX });
+  }
+
+  /** 파일 내려놓기 */
+  dropFile() {
+    return this._send('drop_file', {});
+  }
+
+  /** 모드 전환 */
+  setMode(mode) {
+    return this._send('set_mode', { mode });
+  }
+
+  /** 진화 트리거 */
+  evolve(stage) {
+    return this._send('evolve', { stage });
+  }
+
+  /**
+   * AI 종합 의사결정 전송
+   * OpenClaw AI가 상황을 분석하고 내린 결정을 한번에 전송
+   */
+  decide(decision) {
+    return this._send('ai_decision', decision);
+  }
+
+  /** 현재 펫 상태 요청 */
+  queryState() {
+    return this._send('query_state', {});
+  }
+
+  /** 사용자 이벤트 리스너 등록 */
+  onUserEvent(callback) {
+    this.on('user_event', callback);
+  }
+
+  disconnect() {
+    this._autoReconnect = false;
+    if (this._reconnectTimer) clearTimeout(this._reconnectTimer);
+    if (this.ws) this.ws.close();
+  }
+}
+
+module.exports = { OpenClawConnector };

package/main/autostart.js

@@ -0,0 +1,42 @@
+/**
+ * 시스템 시작 시 ClawMate 자동 실행 등록
+ *
+ * Windows: 레지스트리 Run 키
+ * macOS: LaunchAgent plist
+ *
+ * OpenClaw이 나중에 켜져도, ClawMate는 이미 돌고 있어서 바로 연결됨.
+ * ClawMate가 먼저 혼자 자율 모드로 돌다가 → OpenClaw 연결되면 AI 모드 전환.
+ */
+const { app } = require('electron');
+const path = require('path');
+const os = require('os');
+
+function isAutoStartEnabled() {
+  return app.getLoginItemSettings().openAtLogin;
+}
+
+function enableAutoStart() {
+  app.setLoginItemSettings({
+    openAtLogin: true,
+    openAsHidden: true,  // 창 없이 백그라운드 시작
+    path: process.execPath,
+    args: [path.resolve(__dirname, '..')],
+  });
+  return true;
+}
+
+function disableAutoStart() {
+  app.setLoginItemSettings({
+    openAtLogin: false,
+  });
+  return true;
+}
+
+function toggleAutoStart() {
+  if (isAutoStartEnabled()) {
+    return disableAutoStart();
+  }
+  return enableAutoStart();
+}
+
+module.exports = { isAutoStartEnabled, enableAutoStart, disableAutoStart, toggleAutoStart };

package/main/desktop-path.js

@@ -0,0 +1,33 @@
+const os = require('os');
+const path = require('path');
+const { execSync } = require('child_process');
+
+/**
+ * OS별 바탕화면 경로 탐지
+ * Windows: PowerShell로 정확한 경로 탐지 (OneDrive 등 대응)
+ * macOS: ~/Desktop
+ */
+function getDesktopPath() {
+  const platform = os.platform();
+
+  if (platform === 'win32') {
+    try {
+      const result = execSync(
+        'powershell -NoProfile -Command "[Environment]::GetFolderPath(\'Desktop\')"',
+        { encoding: 'utf-8', timeout: 5000 }
+      ).trim();
+      if (result && result.length > 0) return result;
+    } catch {
+      // PowerShell 실패 시 폴백
+    }
+
+    // 환경 변수 기반 폴백
+    const userProfile = process.env.USERPROFILE || os.homedir();
+    return path.join(userProfile, 'Desktop');
+  }
+
+  // macOS / Linux
+  return path.join(os.homedir(), 'Desktop');
+}
+
+module.exports = { getDesktopPath };

package/main/file-ops.js

@@ -0,0 +1,146 @@
+const fs = require('fs');
+const path = require('path');
+const { getDesktopPath } = require('./desktop-path');
+const manifest = require('./manifest');
+
+/**
+ * 바탕화면 파일 이동 시스템 (안전장치 포함)
+ *
+ * 안전 규칙:
+ * - 세션당 최대 3개 파일만 이동
+ * - 이동 간 최소 5분 쿨다운
+ * - 위험한 확장자 제외
+ * - 100MB 이상 파일 제외
+ * - 바탕화면 폴더 내에서만 위치 변경
+ */
+
+const MAX_FILES_PER_SESSION = 3;
+const COOLDOWN_MS = 5 * 60 * 1000;
+const MAX_FILE_SIZE = 100 * 1024 * 1024;
+const EXCLUDED_EXTS = new Set([
+  '.exe', '.dll', '.sys', '.lnk', '.ini', '.bat', '.cmd',
+  '.ps1', '.msi', '.scr', '.com', '.pif',
+]);
+
+let sessionMoveCount = 0;
+let lastMoveTime = 0;
+
+/**
+ * 바탕화면 파일 목록 가져오기 (안전한 파일만)
+ */
+async function getDesktopFiles() {
+  const desktop = getDesktopPath();
+  try {
+    const entries = await fs.promises.readdir(desktop, { withFileTypes: true });
+    const files = [];
+
+    for (const entry of entries) {
+      if (!entry.isFile()) continue;
+      const ext = path.extname(entry.name).toLowerCase();
+      if (EXCLUDED_EXTS.has(ext)) continue;
+      if (entry.name.startsWith('.')) continue;
+
+      try {
+        const stat = await fs.promises.stat(path.join(desktop, entry.name));
+        if (stat.size > MAX_FILE_SIZE) continue;
+        files.push({
+          name: entry.name,
+          size: stat.size,
+          ext: ext,
+        });
+      } catch {
+        continue;
+      }
+    }
+
+    return files;
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * 바탕화면 내에서 파일 이름 변경(위치 변경 시뮬레이션)
+ * 실제로는 바탕화면 폴더 안에서만 이동 가능
+ * newPosition은 렌더러에서 전달한 좌표 (로그용)
+ */
+async function moveFile(fileName, newPosition) {
+  // 안전장치 체크
+  if (sessionMoveCount >= MAX_FILES_PER_SESSION) {
+    return { success: false, error: '세션당 이동 한도(3개) 초과' };
+  }
+
+  const now = Date.now();
+  if (now - lastMoveTime < COOLDOWN_MS && lastMoveTime > 0) {
+    const remaining = Math.ceil((COOLDOWN_MS - (now - lastMoveTime)) / 1000);
+    return { success: false, error: `쿨다운 중 (${remaining}초 남음)` };
+  }
+
+  const desktop = getDesktopPath();
+  const filePath = path.join(desktop, fileName);
+
+  // 파일 존재 확인
+  try {
+    await fs.promises.access(filePath);
+  } catch {
+    return { success: false, error: '파일을 찾을 수 없음' };
+  }
+
+  // 확장자 체크
+  const ext = path.extname(fileName).toLowerCase();
+  if (EXCLUDED_EXTS.has(ext)) {
+    return { success: false, error: '보호된 파일 유형' };
+  }
+
+  // 크기 체크
+  try {
+    const stat = await fs.promises.stat(filePath);
+    if (stat.size > MAX_FILE_SIZE) {
+      return { success: false, error: '파일 크기 초과 (100MB)' };
+    }
+  } catch {
+    return { success: false, error: '파일 정보 읽기 실패' };
+  }
+
+  // 이동 기록 (바탕화면 내부 이동이므로 실제 파일시스템 위치는 동일)
+  const entry = manifest.addEntry({
+    fileName,
+    originalPath: filePath,
+    position: newPosition,
+    action: 'move',
+  });
+
+  sessionMoveCount++;
+  lastMoveTime = now;
+
+  return { success: true, moveId: entry.id };
+}
+
+/**
+ * 단일 파일 이동 되돌리기
+ */
+async function undoFileMove(moveId) {
+  const entry = manifest.markRestored(moveId);
+  if (!entry) {
+    return { success: false, error: '이동 기록을 찾을 수 없음' };
+  }
+  // 실제 파일 위치는 바탕화면 내에서만 변경되므로 기록만 업데이트
+  return { success: true };
+}
+
+/**
+ * 모든 파일 이동 되돌리기
+ */
+async function undoAllMoves() {
+  const count = manifest.markAllRestored();
+  return { success: true, restoredCount: count };
+}
+
+/**
+ * 파일 이동 이력 가져오기
+ */
+async function getFileManifest() {
+  return manifest.getAll();
+}
+
+module.exports = { getDesktopFiles, moveFile, undoFileMove, undoAllMoves, getFileManifest };

package/main/index.js

@@ -0,0 +1,128 @@
+const { app, BrowserWindow, screen } = require('electron');
+const path = require('path');
+const { setupTray } = require('./tray');
+const { registerIpcHandlers } = require('./ipc-handlers');
+const { AIBridge } = require('./ai-bridge');
+
+let mainWindow = null;
+let launcherWindow = null;
+let aiBridge = null;
+
+function createMainWindow() {
+  const { width, height } = screen.getPrimaryDisplay().workAreaSize;
+
+  mainWindow = new BrowserWindow({
+    width,
+    height,
+    x: 0,
+    y: 0,
+    transparent: true,
+    frame: false,
+    alwaysOnTop: true,
+    skipTaskbar: true,
+    resizable: false,
+    hasShadow: false,
+    webPreferences: {
+      preload: path.join(__dirname, '..', 'preload', 'preload.js'),
+      contextIsolation: true,
+      nodeIntegration: false,
+    },
+  });
+
+  // 클릭 통과 — 펫 영역만 클릭 가능하도록 렌더러에서 제어
+  mainWindow.setIgnoreMouseEvents(true, { forward: true });
+
+  mainWindow.loadFile(path.join(__dirname, '..', 'renderer', 'index.html'));
+  mainWindow.setVisibleOnAllWorkspaces(true, { visibleOnFullScreen: true });
+
+  mainWindow.on('closed', () => {
+    mainWindow = null;
+  });
+
+  return mainWindow;
+}
+
+function createLauncherWindow() {
+  launcherWindow = new BrowserWindow({
+    width: 360,
+    height: 480,
+    resizable: false,
+    frame: false,
+    transparent: true,
+    webPreferences: {
+      preload: path.join(__dirname, '..', 'preload', 'preload.js'),
+      contextIsolation: true,
+      nodeIntegration: false,
+    },
+  });
+
+  launcherWindow.loadFile(path.join(__dirname, '..', 'renderer', 'launcher.html'));
+  launcherWindow.center();
+
+  launcherWindow.on('closed', () => {
+    launcherWindow = null;
+  });
+
+  return launcherWindow;
+}
+
+/**
+ * AI Bridge 시작 — OpenClaw 에이전트가 접속하면 펫을 조종
+ */
+function startAIBridge(win) {
+  aiBridge = new AIBridge();
+  aiBridge.start();
+
+  // OpenClaw → ClawMate 명령을 렌더러에 전달
+  const commandTypes = [
+    'action', 'move', 'emote', 'speak', 'think',
+    'carry_file', 'drop_file', 'set_mode', 'evolve',
+    'accessorize', 'ai_decision',
+  ];
+
+  commandTypes.forEach((type) => {
+    aiBridge.on(type, (payload) => {
+      if (win && !win.isDestroyed()) {
+        win.webContents.send('ai-command', { type, payload });
+      }
+    });
+  });
+
+  // 연결/해제 이벤트
+  aiBridge.on('connected', () => {
+    if (win && !win.isDestroyed()) {
+      win.webContents.send('ai-connected');
+    }
+  });
+
+  aiBridge.on('disconnected', () => {
+    if (win && !win.isDestroyed()) {
+      win.webContents.send('ai-disconnected');
+    }
+  });
+
+  return aiBridge;
+}
+
+app.whenReady().then(() => {
+  registerIpcHandlers(() => mainWindow, () => aiBridge);
+  const win = createMainWindow();
+  const bridge = startAIBridge(win);
+  setupTray(win, bridge);
+
+  // 최초 설치 시 자동 시작 등록
+  const { enableAutoStart, isAutoStartEnabled } = require('./autostart');
+  if (!isAutoStartEnabled()) {
+    enableAutoStart();
+  }
+});
+
+app.on('window-all-closed', () => {
+  // 트레이에서 계속 실행
+});
+
+app.on('before-quit', () => {
+  if (aiBridge) aiBridge.stop();
+});
+
+module.exports = { createMainWindow, createLauncherWindow };

package/main/ipc-handlers.js

@@ -0,0 +1,104 @@
+const { ipcMain, screen } = require('electron');
+const { getDesktopFiles, moveFile, undoFileMove, undoAllMoves, getFileManifest } = require('./file-ops');
+const Store = require('./store');
+
+const store = new Store('clawmate-config', {
+  mode: 'pet',
+  fileInteraction: true,
+  soundEnabled: false,
+});
+
+const memoryStore = new Store('clawmate-memory', {
+  totalClicks: 0,
+  totalDays: 0,
+  firstRunDate: null,
+  milestones: [],
+});
+
+function registerIpcHandlers(getMainWindow, getAIBridge) {
+  // 클릭 통과 제어
+  ipcMain.on('set-click-through', (event, ignore) => {
+    const win = getMainWindow();
+    if (win) {
+      win.setIgnoreMouseEvents(ignore, { forward: true });
+    }
+  });
+
+  // 파일 작업
+  ipcMain.handle('get-desktop-files', async () => getDesktopFiles());
+  ipcMain.handle('move-file', async (_, fileName, newPos) => moveFile(fileName, newPos));
+  ipcMain.handle('undo-file-move', async (_, moveId) => undoFileMove(moveId));
+  ipcMain.handle('undo-all-moves', async () => undoAllMoves());
+  ipcMain.handle('get-file-manifest', async () => getFileManifest());
+
+  // 모드
+  ipcMain.handle('get-mode', () => store.get('mode'));
+  ipcMain.handle('set-mode', (_, mode) => {
+    store.set('mode', mode);
+    const win = getMainWindow();
+    if (win) win.webContents.send('mode-changed', mode);
+    return mode;
+  });
+
+  // 설정
+  ipcMain.handle('get-config', () => store.getAll());
+  ipcMain.handle('set-config', (_, key, value) => {
+    store.set(key, value);
+    const win = getMainWindow();
+    if (win) win.webContents.send('config-changed', store.getAll());
+    return true;
+  });
+
+  // 메모리
+  ipcMain.handle('get-memory', () => memoryStore.getAll());
+  ipcMain.handle('save-memory', (_, data) => {
+    Object.entries(data).forEach(([key, value]) => memoryStore.set(key, value));
+    return true;
+  });
+
+  // 화면 크기
+  ipcMain.handle('get-screen-size', () => {
+    const { width, height } = screen.getPrimaryDisplay().workAreaSize;
+    return { width, height };
+  });
+
+  // === OpenClaw AI 통신 ===
+
+  // 사용자 이벤트를 AI Bridge로 전달 (렌더러 → main → OpenClaw)
+  ipcMain.on('report-to-ai', (_, event, data) => {
+    const bridge = getAIBridge();
+    if (bridge && bridge.isConnected()) {
+      switch (event) {
+        case 'click':
+          bridge.reportUserClick(data.position);
+          break;
+        case 'drag':
+          bridge.reportUserDrag(data.from, data.to);
+          break;
+        case 'cursor_near':
+          bridge.reportCursorNear(data.distance, data.cursorPos);
+          break;
+        case 'desktop_changed':
+          bridge.reportDesktopChange(data.files);
+          break;
+        case 'time_change':
+          bridge.reportTimeChange(data.hour, data.period);
+          break;
+        case 'milestone':
+          bridge.reportMilestone(data.milestone, data);
+          break;
+        case 'user_idle':
+          bridge.reportIdleTime(data.idleSeconds);
+          break;
+      }
+    }
+  });
+
+  // AI 연결 상태 확인
+  ipcMain.handle('is-ai-connected', () => {
+    const bridge = getAIBridge();
+    return bridge ? bridge.isConnected() : false;
+  });
+}
+
+module.exports = { registerIpcHandlers };

package/main/manifest.js

@@ -0,0 +1,70 @@
+const fs = require('fs');
+const path = require('path');
+const { app } = require('electron');
+
+/**
+ * 파일 이동 이력 관리 (Undo 지원)
+ * 모든 파일 이동을 기록하고, 복원 가능하게 관리
+ */
+const MANIFEST_FILE = () => path.join(app.getPath('userData'), 'file-manifest.json');
+
+function loadManifest() {
+  try {
+    const raw = fs.readFileSync(MANIFEST_FILE(), 'utf-8');
+    return JSON.parse(raw);
+  } catch {
+    return [];
+  }
+}
+
+function saveManifest(manifest) {
+  fs.mkdirSync(path.dirname(MANIFEST_FILE()), { recursive: true });
+  fs.writeFileSync(MANIFEST_FILE(), JSON.stringify(manifest, null, 2));
+}
+
+function addEntry(entry) {
+  const manifest = loadManifest();
+  manifest.push({
+    id: Date.now().toString(36) + Math.random().toString(36).slice(2, 6),
+    timestamp: new Date().toISOString(),
+    restored: false,
+    ...entry,
+  });
+  saveManifest(manifest);
+  return manifest[manifest.length - 1];
+}
+
+function markRestored(moveId) {
+  const manifest = loadManifest();
+  const entry = manifest.find(m => m.id === moveId);
+  if (entry) {
+    entry.restored = true;
+    entry.restoredAt = new Date().toISOString();
+    saveManifest(manifest);
+  }
+  return entry;
+}
+
+function markAllRestored() {
+  const manifest = loadManifest();
+  let count = 0;
+  manifest.forEach(entry => {
+    if (!entry.restored) {
+      entry.restored = true;
+      entry.restoredAt = new Date().toISOString();
+      count++;
+    }
+  });
+  saveManifest(manifest);
+  return count;
+}
+
+function getPendingRestores() {
+  return loadManifest().filter(m => !m.restored);
+}
+
+function getAll() {
+  return loadManifest();
+}
+
+module.exports = { addEntry, markRestored, markAllRestored, getPendingRestores, getAll };