ohmypetbook 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 bdhwan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,71 @@
+# 🐾 OhMyPetBook
+
+OpenClaw 디바이스 동기화 데몬. 각 디바이스를 하나의 "pet"으로 등록하고, Firestore를 통해 설정/환경변수/워크스페이스를 실시간 동기화합니다.
+
+## 설치
+
+### npm (권장)
+
+```bash
+npm install -g ohmypetbook
+```
+
+### 원라인 설치
+
+```bash
+# 설치 + 로그인
+curl -fsSL https://ohmypetbook.com/install.sh | bash -s -- --login
+
+# 설치만
+curl -fsSL https://ohmypetbook.com/install.sh | bash
+```
+
+## 사용법
+
+```bash
+# 로그인 (브라우저 인증)
+ohmypetbook login
+
+# 서비스 등록 (자동 시작)
+ohmypetbook install
+
+# 포그라운드 실행
+ohmypetbook run
+
+# 상태 확인
+ohmypetbook status
+
+# 설정 확인/변경
+ohmypetbook config
+ohmypetbook config set openclawPath /path/to/.openclaw
+
+# 서비스 제거
+ohmypetbook uninstall
+
+# 로그아웃 (인증 + 서비스 제거)
+ohmypetbook logout
+```
+
+## 동작 방식
+
+1. `ohmypetbook login` → 브라우저가 열리고 로그인/승인
+2. 디바이스가 `users/{uid}/pets/{petId}`에 등록됨
+3. `~/.openclaw/openclaw.json`, `~/.openclaw/workspace/` 파일을 Firestore와 실시간 동기화
+4. 브라우저([ohmypetbook.com](https://ohmypetbook.com))에서 설정 편집 가능
+5. 환경변수/시크릿 변경 시 `~/.openclaw/.env`에 반영 후 게이트웨이 자동 재시작
+
+## 보안
+
+- `openclaw.json`은 **암호화**되어 Firestore에 저장 (AES-256-GCM)
+- 시크릿은 서버사이드 암호화, `.env`에만 평문 저장 (chmod 600)
+- 암호화 키는 90일마다 자동 로테이션
+- Firebase Auth로 본인 인증, Firestore Rules로 접근 제어
+
+## 요구사항
+
+- Node.js 18+
+- [OpenClaw](https://openclaw.ai) 설치됨
+
+## 라이선스
+
+MIT

package/daemon.js

@@ -0,0 +1,402 @@
+#!/usr/bin/env node
+
+import { initializeApp } from "firebase/app";
+import { getAuth, signInWithCustomToken, signInAnonymously } from "firebase/auth";
+import { getFirestore, doc, setDoc, getDoc, onSnapshot } from "firebase/firestore";
+import { execSync } from "child_process";
+import fs from "fs";
+import path from "path";
+import os from "os";
+import crypto from "crypto";
+import readline from "readline";
+
+import { firebaseConfig, PETBOOK_CONFIG, CONFIG_FILE, LOG_FILE, OPENCLAW_HOME, CLIENT_URL, CLAIM_DEVICE_URL, REFRESH_SESSION_URL, DECRYPT_SECRETS_URL } from "./lib/config.js";
+import { log } from "./lib/log.js";
+import {
+  loadAuth, saveAuth, savePetbookConfig, loadPetbookConfig,
+  generatePetId, deviceInfo, validatePet, setPetOffline
+} from "./lib/auth.js";
+import { pushToFirestore, listenFirestore, watchLocal, initRemoteHash, setLoadEnvSecretsCallback, setPushRef, setGetIdTokenCallback } from "./lib/sync.js";
+import { installService, uninstallService } from "./lib/service.js";
+
+const app = initializeApp(firebaseConfig);
+const auth = getAuth(app);
+const db = getFirestore(app);
+
+// ── Helpers ──
+
+function prompt(question) {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise(resolve => rl.question(question, ans => { rl.close(); resolve(ans.trim()); }));
+}
+
+function generateRequestId() {
+  return crypto.randomBytes(16).toString("base64url");
+}
+
+async function restoreSession(refreshToken) {
+  const tokenResp = await fetch(
+    `https://securetoken.googleapis.com/v1/token?key=${firebaseConfig.apiKey}`,
+    {
+      method: "POST",
+      headers: { "Content-Type": "application/x-www-form-urlencoded" },
+      body: `grant_type=refresh_token&refresh_token=${encodeURIComponent(refreshToken)}`,
+    }
+  );
+  if (!tokenResp.ok) throw new Error("refresh token 만료");
+  const tokenData = await tokenResp.json();
+
+  const resp = await fetch(REFRESH_SESSION_URL, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ idToken: tokenData.id_token }),
+  });
+  if (!resp.ok) throw new Error("세션 복원 실패");
+  const { customToken } = await resp.json();
+
+  const cred = await signInWithCustomToken(auth, customToken);
+  const saved = loadAuth();
+  if (cred.user.refreshToken !== saved.refreshToken) {
+    saveAuth({ ...saved, refreshToken: cred.user.refreshToken });
+  }
+}
+
+// ── 환경변수 & 시크릿 로딩 ──
+
+async function loadEnvAndSecrets(uid, petId) {
+  try {
+    // 1. 계정 레벨
+    const userSnap = await getDoc(doc(db, "users", uid));
+    const userData = userSnap.exists() ? userSnap.data() : {};
+
+    // 2. 디바이스/워크스페이스 레벨 (pet doc에 이미 있음)
+    const petSnap = await getDoc(doc(db, "users", uid, "pets", petId));
+    const petData = petSnap.exists() ? petSnap.data() : {};
+
+    // 환경변수 머지 (계정 < 디바이스)
+    const envVars = {
+      ...(userData.envVars || {}),
+      ...(petData.deviceEnvVars || {}),
+    };
+
+    // 시크릿 머지 (계정 < 디바이스)
+    const allSecrets = {
+      ...(userData.secrets || {}),
+      ...(petData.deviceSecrets || {}),
+    };
+
+    // 시크릿 복호화
+    if (Object.keys(allSecrets).length > 0) {
+      try {
+        const idToken = await auth.currentUser.getIdToken();
+        const resp = await fetch(DECRYPT_SECRETS_URL, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ idToken, secrets: allSecrets }),
+        });
+        if (resp.ok) {
+          const { values } = await resp.json();
+          for (const [key, value] of Object.entries(values)) {
+            if (value !== null) envVars[key] = String(value);
+          }
+        } else {
+          log("⚠️ 시크릿 복호화 실패");
+        }
+      } catch (e) {
+        log(`⚠️ 시크릿 복호화 에러: ${e.message}`);
+      }
+    }
+
+    // .env 파일에 쓰기 → openclaw gateway가 읽음
+    if (Object.keys(envVars).length > 0) {
+      const envPath = path.join(OPENCLAW_HOME, ".env");
+      const lines = Object.entries(envVars)
+        .filter(([k, v]) => k && v !== undefined)
+        .map(([k, v]) => `${k}=${v}`);
+      fs.writeFileSync(envPath, lines.join("\n") + "\n", "utf-8");
+      fs.chmodSync(envPath, 0o600);
+      log(`🔑 .env 업데이트 (${lines.length}개 변수)`);
+    }
+  } catch (e) {
+    log(`⚠️ 환경변수 로드 실패: ${e.message}`);
+  }
+}
+
+// ── Commands ──
+
+async function cmdLogin() {
+  const codeArg = process.argv[3];
+  const petId = generatePetId();
+  const info = deviceInfo();
+
+  // 코드가 직접 주어진 경우 → 바로 등록
+  if (codeArg) {
+    return doClaimDevice(codeArg, petId, info);
+  }
+
+  // 1. 익명 로그인
+  await signInAnonymously(auth);
+  const requestId = generateRequestId();
+
+  // 2. loginRequests 문서 생성
+  await setDoc(doc(db, "loginRequests", requestId), {
+    petId,
+    ...info,
+    status: "pending",
+    createdAt: new Date().toISOString(),
+    expiresAt: new Date(Date.now() + 10 * 60 * 1000).toISOString(),
+  });
+
+  // 3. URL 표시
+  const url = `${CLIENT_URL}/auth/device?requestId=${requestId}`;
+
+  console.log("");
+  console.log("  \x1b[1m🐾 OhMyPetBook 기기 등록\x1b[0m");
+  console.log("");
+  console.log("  아래 URL을 브라우저에서 열어주세요:");
+  console.log(`  \x1b[4m\x1b[36m${url}\x1b[0m`);
+  console.log("");
+
+  // 4. Firestore 구독 + 수동 입력 동시 대기
+  const result = await new Promise((resolve, reject) => {
+    let settled = false;
+
+    // Firestore 실시간 구독
+    const unsub = onSnapshot(doc(db, "loginRequests", requestId), (snap) => {
+      const data = snap.data();
+      if (data?.status === "approved" && data?.customToken && !settled) {
+        settled = true;
+        unsub();
+        resolve({ type: "auto", customToken: data.customToken, uid: data.uid, email: data.email });
+      }
+    });
+
+    // 수동 코드 입력 (폴백)
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    console.log("  브라우저에서 승인하면 자동으로 진행됩니다.");
+    console.log("  또는 등록 코드를 직접 입력하세요:");
+    console.log("");
+    rl.question("  등록 코드 (자동 대기 중...): ", (code) => {
+      rl.close();
+      if (!settled && code.trim()) {
+        settled = true;
+        unsub();
+        resolve({ type: "manual", code: code.trim() });
+      }
+    });
+
+    // 10분 타임아웃
+    setTimeout(() => {
+      if (!settled) {
+        settled = true;
+        unsub();
+        reject(new Error("등록 시간 초과 (10분)"));
+      }
+    }, 10 * 60 * 1000);
+  });
+
+  if (result.type === "auto") {
+    // 자동 승인 — customToken으로 바로 로그인
+    console.log("\n  ✅ 브라우저에서 승인됨!");
+    const cred = await signInWithCustomToken(auth, result.customToken);
+    const petName = info.hostname || os.hostname();
+
+    saveAuth({
+      uid: result.uid,
+      email: result.email,
+      petId,
+      petName,
+      refreshToken: cred.user.refreshToken,
+      savedAt: new Date().toISOString()
+    });
+
+    printSuccess(result.email, petName, petId);
+  } else {
+    // 수동 코드 입력
+    await doClaimDevice(result.code, petId, info);
+  }
+}
+
+async function doClaimDevice(code, petId, info) {
+  console.log("  🔐 등록 중...");
+
+  const resp = await fetch(CLAIM_DEVICE_URL, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ code, petId, deviceInfo: info }),
+  });
+
+  if (!resp.ok) {
+    const err = await resp.json().catch(() => ({}));
+    console.error(`  ❌ ${err.error || `등록 실패 (${resp.status})`}`);
+    process.exit(1);
+  }
+
+  const { customToken, uid, email } = await resp.json();
+  const cred = await signInWithCustomToken(auth, customToken);
+  const petName = info.hostname || os.hostname();
+
+  saveAuth({
+    uid,
+    email,
+    petId,
+    petName,
+    refreshToken: cred.user.refreshToken,
+    savedAt: new Date().toISOString()
+  });
+
+  printSuccess(email, petName, petId);
+}
+
+function printSuccess(email, petName, petId) {
+  console.log(`  ✓ 계정: \x1b[1m${email}\x1b[0m`);
+  console.log(`  ✓ Pet: \x1b[1m${petName}\x1b[0m (\x1b[2m${petId.slice(0, 16)}...\x1b[0m)`);
+  console.log("");
+  console.log("  다음 단계:");
+  console.log("    \x1b[1mohmypetbook install\x1b[0m  — 서비스 등록 (자동 시작)");
+  console.log("    \x1b[1mohmypetbook run\x1b[0m      — 포그라운드 실행");
+  console.log("");
+}
+
+async function cmdRun() {
+  const saved = loadAuth();
+  if (!saved?.refreshToken) {
+    log("❌ 인증 정보 없음. `ohmypetbook login` 먼저 실행하세요.");
+    process.exit(1);
+  }
+
+  log(`🐾 ${saved.petName || "pet"} 시작 (${saved.email})`);
+
+  try {
+    await restoreSession(saved.refreshToken);
+  } catch (e) {
+    log(`❌ 인증 실패: ${e.message}. 재등록 필요: ohmypetbook login`);
+    process.exit(1);
+  }
+
+  const uid = auth.currentUser.uid;
+  const petId = saved.petId;
+  log(`✓ 인증 완료: ${auth.currentUser.email}`);
+
+  if (!(await validatePet(db, uid, petId))) {
+    process.exit(1);
+  }
+
+  await loadEnvAndSecrets(uid, petId);
+  setLoadEnvSecretsCallback(() => loadEnvAndSecrets(uid, petId));
+  setPushRef(() => pushToFirestore(db, uid, petId));
+  setGetIdTokenCallback(() => auth.currentUser.getIdToken());
+
+  initRemoteHash();
+  await pushToFirestore(db, uid, petId);
+  listenFirestore(db, uid, petId);
+  log("👂 Firestore 실시간 리스너 시작");
+
+  watchLocal(db, uid, petId);
+  log("👀 로컬 파일 감시 시작");
+  log("🚀 데몬 실행 중...");
+
+  const shutdown = async () => {
+    log("종료 중...");
+    await setPetOffline(db, uid, petId);
+    process.exit(0);
+  };
+  process.on("SIGTERM", shutdown);
+  process.on("SIGINT", shutdown);
+}
+
+function cmdStatus() {
+  const saved = loadAuth();
+  console.log("\n  \x1b[1m🐾 OhMyPetBook Status\x1b[0m\n");
+  if (saved) {
+    const expired = saved.expiresAt && new Date(saved.expiresAt) < new Date();
+    console.log(`  Pet:   ${saved.petName || "N/A"} (${saved.petId?.slice(0, 16) || "N/A"}...)`);
+    console.log(`  계정:  ${saved.email}`);
+    console.log(`  만료:  ${saved.expiresAt ? new Date(saved.expiresAt).toLocaleDateString("ko-KR") : "N/A"} ${expired ? "\x1b[31m(만료됨)\x1b[0m" : "\x1b[32m(유효)\x1b[0m"}`);
+    console.log(`  경로:  ${OPENCLAW_HOME}`);
+    console.log(`  설정:  ${CONFIG_FILE}`);
+  } else {
+    console.log("  \x1b[33m등록된 pet 없음. ohmypetbook login 실행하세요.\x1b[0m");
+  }
+
+  const platform = os.platform();
+  if (platform === "darwin") {
+    try {
+      execSync("launchctl list | grep ohmypetbook", { stdio: "pipe" });
+      console.log("  서비스: \x1b[32m실행 중\x1b[0m");
+    } catch { console.log("  서비스: \x1b[33m미등록\x1b[0m"); }
+  } else if (platform === "linux") {
+    try {
+      const s = execSync("systemctl --user is-active petbook-daemon", { encoding: "utf-8" }).trim();
+      console.log(`  서비스: \x1b[32m${s}\x1b[0m`);
+    } catch { console.log("  서비스: \x1b[33m미등록\x1b[0m"); }
+  }
+  console.log(`  로그:  ${LOG_FILE}\n`);
+}
+
+// ── Main ──
+
+const [,, command] = process.argv;
+
+switch (command) {
+  case "login":     await cmdLogin(); break;
+  case "run":       await cmdRun(); break;
+  case "install": {
+    if (!loadAuth()?.refreshToken) { console.error("❌ 먼저 등록: ohmypetbook login"); process.exit(1); }
+    installService();
+    console.log("\n  ✓ 서비스 등록 완료. 데몬이 백그라운드에서 실행됩니다.\n");
+    break;
+  }
+  case "uninstall":
+    uninstallService();
+    console.log("  ✓ 서비스 제거 완료\n");
+    break;
+  case "status":
+    cmdStatus();
+    break;
+  case "config": {
+    const [,,, key, ...rest] = process.argv;
+    if (key === "openclawPath" && rest.length) {
+      savePetbookConfig({ openclawPath: rest.join(" ") });
+      console.log(`  ✓ openclawPath = ${rest.join(" ")}`);
+    } else {
+      const cfg = loadPetbookConfig();
+      console.log("\n  \x1b[1m~/.ohmypetbook/ohmypetbook.json\x1b[0m\n");
+      console.log(`  openclawPath: ${cfg.openclawPath || "~/.openclaw (기본값)"}`);
+      console.log(`  pet:          ${cfg.auth?.petName || "없음"} (${cfg.auth?.petId?.slice(0, 16) || "N/A"})`);
+      console.log(`  계정:         ${cfg.auth?.email || "없음"}`);
+      console.log("");
+      console.log("  변경: ohmypetbook config openclawPath /path/to/.openclaw");
+      console.log("");
+    }
+    break;
+  }
+  case "logout": {
+    const saved = loadAuth();
+    if (saved?.petId && saved?.uid && saved?.refreshToken) {
+      try {
+        await restoreSession(saved.refreshToken);
+        await setPetOffline(db, saved.uid, saved.petId);
+      } catch {}
+    }
+    uninstallService();
+    if (fs.existsSync(PETBOOK_CONFIG)) fs.unlinkSync(PETBOOK_CONFIG);
+    console.log("\n  ✓ 로그아웃 + 서비스 제거 완료\n");
+    break;
+  }
+  default:
+    console.log(`
+  \x1b[1m🐾 ohmypetbook\x1b[0m — OpenClaw 디바이스 동기화 데몬
+
+  각 디바이스 = 1 pet. Firestore와 실시간 동기화.
+
+  \x1b[1mCommands:\x1b[0m
+    ohmypetbook login [코드]  기기 등록 (URL + 자동승인 / 코드 수동입력)
+    ohmypetbook install       서비스 등록 (부팅 시 자동 시작)
+    ohmypetbook uninstall     서비스 제거
+    ohmypetbook run           포그라운드 실행
+    ohmypetbook status        상태 확인
+    ohmypetbook config        설정 확인/변경 (openclawPath 등)
+    ohmypetbook logout        pet 해제 + 서비스 제거
+    `);
+}

package/lib/auth.js

@@ -0,0 +1,137 @@
+import {
+  signInWithEmailAndPassword,
+  signInWithCredential, GoogleAuthProvider
+} from "firebase/auth";
+import { doc, getDoc, setDoc, updateDoc } from "firebase/firestore";
+import crypto from "crypto";
+import { execSync } from "child_process";
+import fs from "fs";
+import os from "os";
+import { PETBOOK_HOME, PETBOOK_CONFIG, OPENCLAW_HOME, TOKEN_EXPIRY_DAYS } from "./config.js";
+import { ensureDir, log } from "./log.js";
+
+// ── ohmypetbook.json 관리 ──
+
+export function savePetbookConfig(data) {
+  ensureDir(PETBOOK_HOME);
+  const existing = loadPetbookConfig();
+  const merged = { ...existing, ...data };
+  fs.writeFileSync(PETBOOK_CONFIG, JSON.stringify(merged, null, 2), "utf-8");
+  fs.chmodSync(PETBOOK_CONFIG, 0o600);
+}
+
+export function loadPetbookConfig() {
+  try { return JSON.parse(fs.readFileSync(PETBOOK_CONFIG, "utf-8")); } catch { return {}; }
+}
+
+export function saveAuth(data) {
+  savePetbookConfig({ auth: data, openclawPath: OPENCLAW_HOME });
+}
+
+export function loadAuth() {
+  return loadPetbookConfig().auth || null;
+}
+
+// ── Token / Verification ──
+
+export function generateVerificationCode() {
+  const chars = "ABCDEFGHJKLMNPQRSTUVWXYZ23456789";
+  let code = "";
+  for (let i = 0; i < 4; i++) code += chars[crypto.randomInt(chars.length)];
+  return code;
+}
+
+export function getDeviceId() {
+  try {
+    const platform = os.platform();
+    let raw;
+    if (platform === "darwin") {
+      raw = execSync("/usr/sbin/ioreg -rd1 -c IOPlatformExpertDevice", { encoding: "utf-8" });
+      const match = raw.match(/"IOPlatformUUID"\s*=\s*"([^"]+)"/);
+      if (match) return match[1];
+    } else if (platform === "linux") {
+      raw = fs.readFileSync("/etc/machine-id", "utf-8").trim();
+      if (raw) return raw;
+    }
+  } catch {}
+  // fallback: hostname + arch
+  return `${os.hostname()}-${os.arch()}`;
+}
+
+export function generatePetId() {
+  const deviceId = getDeviceId();
+  const hash = crypto.createHash("sha256").update(deviceId).digest("hex").slice(0, 16);
+  return `pet_${hash}`;
+}
+
+// ── Firebase Auth ──
+
+export async function signInFromCredential(auth, credData) {
+  if (credData.type === "email") {
+    return signInWithEmailAndPassword(auth, credData.email, credData.password);
+  } else if (credData.type === "google") {
+    const credential = GoogleAuthProvider.credential(credData.googleIdToken);
+    return signInWithCredential(auth, credential);
+  }
+  throw new Error(`지원하지 않는 인증 타입: ${credData.type}`);
+}
+
+// ── Pet 등록/검증 (Firestore) ──
+
+export function deviceInfo() {
+  return {
+    hostname: os.hostname(),
+    platform: os.platform(),
+    arch: os.arch(),
+    nodeVersion: process.version
+  };
+}
+
+export async function registerPet(db, uid, petName) {
+  const petId = generatePetId();
+  const expiresAt = new Date(Date.now() + TOKEN_EXPIRY_DAYS * 24 * 60 * 60 * 1000).toISOString();
+  const now = new Date().toISOString();
+
+  await setDoc(doc(db, "users", uid, "pets", petId), {
+    name: petName || os.hostname(),
+    ...deviceInfo(),
+    openclawPath: OPENCLAW_HOME,
+    createdAt: now,
+    expiresAt,
+    lastSeen: now,
+    status: "online",
+    revoked: false
+  }, { merge: true });
+
+  return { petId, expiresAt };
+}
+
+export async function validatePet(db, uid, petId) {
+  if (!petId) return true;
+  const snap = await getDoc(doc(db, "users", uid, "pets", petId));
+  if (!snap.exists()) return true;
+
+  const data = snap.data();
+  if (data.revoked) {
+    log("🚫 이 pet이 폐기되었습니다. 재등록 필요.");
+    return false;
+  }
+
+  // lastSeen + status 업데이트
+  await updateDoc(doc(db, "users", uid, "pets", petId), {
+    lastSeen: new Date().toISOString(),
+    status: "online",
+    ...deviceInfo()
+  });
+  return true;
+}
+
+export async function setPetOffline(db, uid, petId) {
+  if (!petId) return;
+  try {
+    await updateDoc(doc(db, "users", uid, "pets", petId), {
+      status: "offline",
+      lastSeen: new Date().toISOString()
+    });
+  } catch {}
+}

package/lib/config.js

@@ -0,0 +1,35 @@
+import os from "os";
+import path from "path";
+import fs from "fs";
+
+export const HOME = os.homedir();
+export const PETBOOK_HOME = path.join(HOME, ".ohmypetbook");
+export const PETBOOK_CONFIG = path.join(PETBOOK_HOME, "ohmypetbook.json");
+export const LOG_FILE = path.join(PETBOOK_HOME, "ohmypetbook.log");
+
+// ohmypetbook.json에서 openclaw 경로 읽기 (기본: ~/.openclaw)
+function loadPetbookConfig() {
+  try { return JSON.parse(fs.readFileSync(PETBOOK_CONFIG, "utf-8")); } catch { return {}; }
+}
+
+const petbookConfig = loadPetbookConfig();
+export const OPENCLAW_HOME = petbookConfig.openclawPath || process.env.OPENCLAW_HOME || path.join(HOME, ".openclaw");
+export const CONFIG_FILE = path.join(OPENCLAW_HOME, "openclaw.json");
+export const CONFIG_DIR = path.join(OPENCLAW_HOME, "openclaw");
+export const WORKSPACE_DIR = path.join(OPENCLAW_HOME, "workspace");
+export const CLIENT_URL = "https://ohmypetbook.com";
+export const TOKEN_EXPIRY_DAYS = 365;
+export const CLAIM_DEVICE_URL = "https://claimdevice-gkspcxvo6q-du.a.run.app";
+export const REFRESH_SESSION_URL = "https://refreshsession-gkspcxvo6q-du.a.run.app";
+export const ENCRYPT_SECRET_URL = "https://asia-northeast3-openclaw-petbook.cloudfunctions.net/encryptSecret";
+export const DECRYPT_SECRETS_URL = "https://asia-northeast3-openclaw-petbook.cloudfunctions.net/decryptSecrets";
+
+export const firebaseConfig = {
+  apiKey: "AIzaSyDaOWYC3U3nMNVoO1hSwE4IndGavOdpr9o",
+  authDomain: "openclaw-petbook.firebaseapp.com",
+  projectId: "openclaw-petbook",
+  storageBucket: "openclaw-petbook.firebasestorage.app",
+  messagingSenderId: "724877033848",
+  appId: "1:724877033848:web:e364e397bb8a71cb00088d",
+  measurementId: "G-W0MB718DVQ"
+};

package/lib/gateway.js

@@ -0,0 +1,39 @@
+import { execSync } from "child_process";
+import fs from "fs";
+import path from "path";
+import { HOME } from "./config.js";
+import { log } from "./log.js";
+
+function findBin(name) {
+  try {
+    return execSync(`which ${name}`, { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+  } catch {
+    try {
+      const nvmDir = path.join(HOME, ".nvm/versions/node");
+      const versions = fs.readdirSync(nvmDir);
+      if (versions.length) {
+        const bin = path.join(nvmDir, versions[versions.length - 1], "bin", name);
+        if (fs.existsSync(bin)) return bin;
+      }
+    } catch {}
+    return null;
+  }
+}
+
+export function restartGateway() {
+  log("🔄 게이트웨이 재시작 중...");
+  try {
+    const bin = findBin("openclaw");
+    if (bin) {
+      // openclaw 바이너리의 디렉토리를 PATH 앞에 추가 (launchd 환경에서 올바른 node 사용)
+      const binDir = path.dirname(bin);
+      const env = { ...process.env, PATH: `${binDir}:${process.env.PATH || ""}` };
+      execSync(`${bin} gateway restart`, { timeout: 30000, stdio: "pipe", env });
+      log("✓ 게이트웨이 재시작 완료");
+    } else {
+      log("⚠ openclaw 명령어를 찾을 수 없음");
+    }
+  } catch (e) {
+    log(`❌ 게이트웨이 재시작 실패: ${e.message}`);
+  }
+}

package/lib/log.js

@@ -0,0 +1,19 @@
+import fs from "fs";
+import { LOG_FILE, PETBOOK_HOME } from "./config.js";
+
+export function ensureDir(dir) {
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+}
+
+export function ts() {
+  return new Date().toLocaleTimeString("ko-KR", { hour12: false });
+}
+
+export function log(msg) {
+  const line = `[${ts()}] ${msg}`;
+  console.log(line);
+  try {
+    ensureDir(PETBOOK_HOME);
+    fs.appendFileSync(LOG_FILE, line + "\n");
+  } catch {}
+}

package/lib/login-server.js

@@ -0,0 +1,86 @@
+import { createServer } from "http";
+import { spawn } from "child_process";
+import crypto from "crypto";
+import os from "os";
+import { CLIENT_URL } from "./config.js";
+import { generateVerificationCode } from "./auth.js";
+
+const SPINNER = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+
+export function waitForBrowserAuth() {
+  return new Promise((resolve, reject) => {
+    const verifyCode = generateVerificationCode();
+    const port = 19876 + crypto.randomInt(1000);
+
+    const server = createServer((req, res) => {
+      res.setHeader("Access-Control-Allow-Origin", "*");
+      res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+      res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+
+      if (req.method === "OPTIONS") { res.writeHead(200); res.end(); return; }
+
+      if (req.method === "GET" && req.url === "/info") {
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({
+          verifyCode,
+          hostname: os.hostname(),
+          platform: os.platform(),
+          arch: os.arch()
+        }));
+        return;
+      }
+
+      if (req.method === "POST" && req.url === "/callback") {
+        let body = "";
+        req.on("data", (chunk) => body += chunk);
+        req.on("end", () => {
+          try {
+            const data = JSON.parse(body);
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ ok: true }));
+            server.close();
+            clearInterval(spinnerInterval);
+            process.stdout.write("\r\x1b[K");
+            resolve(data);
+          } catch {
+            res.writeHead(400);
+            res.end("Invalid payload");
+          }
+        });
+        return;
+      }
+      res.writeHead(404);
+      res.end();
+    });
+
+    server.listen(port, () => {
+      const authUrl = `${CLIENT_URL}/auth/device?port=${port}`;
+      console.log("");
+      console.log("  \x1b[1m🔐 OhMyPetBook 로그인\x1b[0m");
+      console.log("");
+      console.log("  브라우저에서 로그인하세요:");
+      console.log(`  \x1b[4m\x1b[36m${authUrl}\x1b[0m`);
+      console.log("");
+      console.log(`  확인 코드: \x1b[1m\x1b[33m${verifyCode}\x1b[0m`);
+      console.log("  (브라우저에 표시되는 코드와 일치하는지 확인하세요)");
+      console.log("");
+
+      try {
+        const cmd = os.platform() === "darwin" ? "open" : "xdg-open";
+        spawn(cmd, [authUrl], { detached: true, stdio: "ignore" }).unref();
+      } catch {}
+    });
+
+    let si = 0;
+    const spinnerInterval = setInterval(() => {
+      process.stdout.write(`\r  ${SPINNER[si++ % SPINNER.length]} 대기 중...`);
+    }, 100);
+
+    server.on("error", (e) => { clearInterval(spinnerInterval); reject(e); });
+    setTimeout(() => {
+      clearInterval(spinnerInterval);
+      server.close();
+      reject(new Error("로그인 타임아웃 (5분)"));
+    }, 5 * 60 * 1000);
+  });
+}

package/lib/service.js

@@ -0,0 +1,83 @@
+import { execSync } from "child_process";
+import fs from "fs";
+import path from "path";
+import os from "os";
+import { fileURLToPath } from "url";
+import { HOME, LOG_FILE } from "./config.js";
+import { ensureDir, log } from "./log.js";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+export function installService() {
+  const platform = os.platform();
+  const nodeBin = process.execPath;
+  const daemonPath = path.resolve(__dirname, "..", "daemon.js");
+
+  if (platform === "darwin") {
+    const label = "com.ohmypetbook.daemon";
+    const plistPath = path.join(HOME, "Library/LaunchAgents", `${label}.plist`);
+    const plist = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key><string>${label}</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${nodeBin}</string>
+    <string>${daemonPath}</string>
+    <string>run</string>
+  </array>
+  <key>RunAtLoad</key><true/>
+  <key>KeepAlive</key><true/>
+  <key>StandardOutPath</key><string>${LOG_FILE}</string>
+  <key>StandardErrorPath</key><string>${LOG_FILE}</string>
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>PATH</key><string>/usr/local/bin:/usr/bin:/bin:${path.dirname(nodeBin)}</string>
+    <key>HOME</key><string>${HOME}</string>
+  </dict>
+</dict>
+</plist>`;
+    ensureDir(path.dirname(plistPath));
+    fs.writeFileSync(plistPath, plist);
+    try { execSync(`launchctl unload ${plistPath} 2>/dev/null`); } catch {}
+    execSync(`launchctl load ${plistPath}`);
+    log(`✓ macOS 서비스 등록: ${label}`);
+
+  } else if (platform === "linux") {
+    const serviceDir = path.join(HOME, ".config/systemd/user");
+    const servicePath = path.join(serviceDir, "ohmyohmypetbook-daemon.service");
+    const unit = `[Unit]
+Description=PetBook Daemon
+After=network-online.target
+Wants=network-online.target
+[Service]
+Type=simple
+ExecStart=${nodeBin} ${daemonPath} run
+Restart=always
+RestartSec=10
+Environment=HOME=${HOME}
+Environment=PATH=/usr/local/bin:/usr/bin:/bin:${path.dirname(nodeBin)}
+[Install]
+WantedBy=default.target`;
+    ensureDir(serviceDir);
+    fs.writeFileSync(servicePath, unit);
+    execSync("systemctl --user daemon-reload");
+    execSync("systemctl --user enable ohmypetbook-daemon");
+    execSync("systemctl --user restart ohmypetbook-daemon");
+    log("✓ Linux 서비스 등록: ohmypetbook-daemon");
+  }
+}
+
+export function uninstallService() {
+  if (os.platform() === "darwin") {
+    const p = path.join(HOME, "Library/LaunchAgents/com.ohmypetbook.daemon.plist");
+    try { execSync(`launchctl unload ${p}`); } catch {}
+    try { fs.unlinkSync(p); } catch {}
+  } else if (os.platform() === "linux") {
+    try { execSync("systemctl --user stop ohmypetbook-daemon"); } catch {}
+    try { execSync("systemctl --user disable ohmypetbook-daemon"); } catch {}
+    try { fs.unlinkSync(path.join(HOME, ".config/systemd/user/ohmyohmypetbook-daemon.service")); } catch {}
+    try { execSync("systemctl --user daemon-reload"); } catch {}
+  }
+}

package/lib/sync.js

@@ -0,0 +1,352 @@
+import { doc, setDoc, updateDoc, onSnapshot, collection, query, where, onSnapshot as onSnapshotCol } from "firebase/firestore";
+import { watch } from "chokidar";
+import fs from "fs";
+import path from "path";
+import os from "os";
+import { CONFIG_FILE, CONFIG_DIR, OPENCLAW_HOME, WORKSPACE_DIR, ENCRYPT_SECRET_URL, DECRYPT_SECRETS_URL } from "./config.js";
+import { deviceInfo } from "./auth.js";
+import { ensureDir, log } from "./log.js";
+import { restartGateway } from "./gateway.js";
+
+// ── .env 파일 관리 ──
+
+const ENV_FILE = path.join(OPENCLAW_HOME, ".env");
+
+// 환경변수+시크릿 로드 콜백 (daemon.js에서 설정, 시크릿 복호화 포함)
+let loadEnvSecretsCallback = null;
+export function setLoadEnvSecretsCallback(fn) { loadEnvSecretsCallback = fn; }
+
+// idToken 콜백 (daemon.js에서 설정)
+let getIdTokenCallback = null;
+export function setGetIdTokenCallback(fn) { getIdTokenCallback = fn; }
+
+// ── config 암호화/복호화 ──
+
+async function encryptConfig(configObj) {
+  if (!getIdTokenCallback) return null;
+  try {
+    const idToken = await getIdTokenCallback();
+    const configStr = JSON.stringify(configObj);
+    const resp = await fetch(ENCRYPT_SECRET_URL, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ idToken, value: configStr }),
+    });
+    if (!resp.ok) throw new Error(`encrypt failed: ${resp.status}`);
+    const { encData } = await resp.json();
+    return encData;
+  } catch (e) {
+    log(`⚠️ config 암호화 실패: ${e.message}`);
+    return null;
+  }
+}
+
+async function decryptConfig(encData) {
+  if (!getIdTokenCallback || !encData) return null;
+  try {
+    const idToken = await getIdTokenCallback();
+    const resp = await fetch(DECRYPT_SECRETS_URL, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ idToken, secrets: { _config: encData } }),
+    });
+    if (!resp.ok) throw new Error(`decrypt failed: ${resp.status}`);
+    const { values } = await resp.json();
+    return values._config ? JSON.parse(values._config) : null;
+  } catch (e) {
+    log(`⚠️ config 복호화 실패: ${e.message}`);
+    return null;
+  }
+}
+
+
+
+let skipLocalWatch = false;
+let skipRemoteWatch = false;
+let lastRemoteHash = "";
+
+export function initRemoteHash() {
+  lastRemoteHash = JSON.stringify(readConfig());
+}
+
+export function readConfig() {
+  try { return JSON.parse(fs.readFileSync(CONFIG_FILE, "utf-8")); } catch { return {}; }
+}
+
+function writeConfig(data) {
+  skipLocalWatch = true;
+  ensureDir(OPENCLAW_HOME);
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify(data, null, 2), "utf-8");
+  log("✓ openclaw.json 업데이트");
+  setTimeout(() => { skipLocalWatch = false; }, 500);
+}
+
+function readOpenclawDir() {
+  ensureDir(CONFIG_DIR);
+  const result = {};
+  for (const f of fs.readdirSync(CONFIG_DIR)) {
+    const fp = path.join(CONFIG_DIR, f);
+    if (fs.statSync(fp).isFile()) result[f] = fs.readFileSync(fp, "utf-8");
+  }
+  return result;
+}
+
+function writeOpenclawDir(files) {
+  ensureDir(CONFIG_DIR);
+  skipLocalWatch = true;
+  for (const [name, content] of Object.entries(files)) {
+    fs.writeFileSync(path.join(CONFIG_DIR, name), content, "utf-8");
+  }
+  log(`✓ openclaw/ 업데이트 (${Object.keys(files).length} files)`);
+  setTimeout(() => { skipLocalWatch = false; }, 500);
+}
+
+// ── 워크스페이스 파일 읽기/쓰기 ──
+
+const WORKSPACE_FILES = ["AGENTS.md", "SOUL.md", "USER.md", "TOOLS.md", "IDENTITY.md", "HEARTBEAT.md"];
+
+function readWorkspace() {
+  const result = {};
+  for (const name of WORKSPACE_FILES) {
+    const fp = path.join(WORKSPACE_DIR, name);
+    try { result[name] = fs.readFileSync(fp, "utf-8"); } catch {}
+  }
+  // memory/ 제외 (용량 이슈)
+  return result;
+}
+
+function writeWorkspace(files) {
+  if (!files) return;
+  skipLocalWatch = true;
+  ensureDir(WORKSPACE_DIR);
+  for (const [name, content] of Object.entries(files)) {
+    if (WORKSPACE_FILES.includes(name) && typeof content === "string") {
+      fs.writeFileSync(path.join(WORKSPACE_DIR, name), content, "utf-8");
+    }
+  }
+  log(`✓ workspace 업데이트`);
+  setTimeout(() => { skipLocalWatch = false; }, 500);
+}
+
+// ── skills 정보 읽기 ──
+
+function readSkillsInfo() {
+  const config = readConfig();
+  const entries = config?.skills?.entries || {};
+  const skills = {};
+  for (const [name, data] of Object.entries(entries)) {
+    skills[name] = typeof data === "object" ? { ...data } : { enabled: true };
+    // apiKey 등 민감정보 마스킹
+    for (const key of Object.keys(skills[name])) {
+      if (/key|token|secret|password/i.test(key)) {
+        skills[name][key] = "***";
+      }
+    }
+  }
+  return skills;
+}
+
+// ── pet 단위로 Firestore 동기화 ──
+
+export async function pushToFirestore(db, uid, petId) {
+  if (skipRemoteWatch) return;
+  skipRemoteWatch = true;
+  try {
+    // config 암호화
+    const rawConfig = readConfig();
+    const encryptedConfig = await encryptConfig(rawConfig);
+
+    const data = {
+      openclawFiles: readOpenclawDir(),
+      workspace: readWorkspace(),
+      skills: readSkillsInfo(),
+      openclawPath: OPENCLAW_HOME,
+      updatedAt: new Date().toISOString(),
+      lastSeen: new Date().toISOString(),
+      status: "online"
+    };
+
+    if (encryptedConfig) {
+      data.encryptedConfig = encryptedConfig;
+      data.config = null; // 평문 제거
+    } else {
+      // 암호화 실패 시 폴백 (최초 로그인 등 idToken 없을 때)
+      data.config = rawConfig;
+    }
+
+    await setDoc(doc(db, "users", uid, "pets", petId), data, { merge: true });
+    log("⬆ 로컬 → Firestore 동기화" + (encryptedConfig ? " (config 암호화)" : ""));
+  } catch (e) {
+    log(`❌ Push 실패: ${e.message}`);
+  }
+  setTimeout(() => { skipRemoteWatch = false; }, 1000);
+}
+
+// ── 커맨드 리스너 (웹 → 데몬) ──
+
+// pushToFirestore 참조 (refresh_info에서 사용)
+let _pushRef = null;
+export function setPushRef(fn) { _pushRef = fn; }
+
+const COMMAND_HANDLERS = {
+  restart_gateway: async () => {
+    restartGateway();
+    return { message: "게이트웨이 재시작 완료" };
+  },
+  refresh_info: async (params, { db, uid, petId }) => {
+    const info = deviceInfo();
+    const uptime = Math.floor(process.uptime());
+    const memTotal = Math.round(os.totalmem() / 1024 / 1024);
+    const memFree = Math.round(os.freemem() / 1024 / 1024);
+
+    // openclaw 버전 정보
+    let openclawVersion = '';
+    try {
+      const { execSync } = await import('child_process');
+      const nvmDir = path.join(os.homedir(), '.nvm/versions/node');
+      const versions = fs.readdirSync(nvmDir);
+      if (versions.length) {
+        const bin = path.join(nvmDir, versions[versions.length - 1], 'bin', 'openclaw');
+        if (fs.existsSync(bin)) {
+          openclawVersion = execSync(`${bin} --version`, { encoding: 'utf-8', timeout: 5000 }).trim();
+        }
+      }
+    } catch {}
+
+    const data = {
+      ...info,
+      uptime,
+      memTotal,
+      memFree,
+      cpus: os.cpus().length,
+      cpuModel: os.cpus()[0]?.model || '',
+      osRelease: os.release(),
+      openclawVersion,
+      lastSeen: new Date().toISOString(),
+      status: "online",
+    };
+    await setDoc(doc(db, "users", uid, "pets", petId), data, { merge: true });
+    if (_pushRef) await _pushRef();
+    return { message: "디바이스 정보 업데이트 완료", ...data };
+  },
+};
+
+function listenCommands(db, uid, petId) {
+  const commandsCol = collection(db, "users", uid, "pets", petId, "commands");
+  const q = query(commandsCol, where("status", "==", "pending"));
+
+  return onSnapshot(q, async (snapshot) => {
+    for (const change of snapshot.docChanges()) {
+      if (change.type !== "added") continue;
+      const cmdDoc = change.doc;
+      const cmd = cmdDoc.data();
+
+      log(`📨 커맨드 수신: ${cmd.action}`);
+
+      const handler = COMMAND_HANDLERS[cmd.action];
+      if (!handler) {
+        await updateDoc(cmdDoc.ref, {
+          status: "error",
+          error: `알 수 없는 커맨드: ${cmd.action}`,
+          completedAt: new Date().toISOString()
+        });
+        continue;
+      }
+
+      try {
+        await updateDoc(cmdDoc.ref, { status: "running" });
+        const result = await handler(cmd.params || {}, { db, uid, petId });
+        await updateDoc(cmdDoc.ref, {
+          status: "done",
+          result: result || {},
+          completedAt: new Date().toISOString()
+        });
+        log(`✓ 커맨드 완료: ${cmd.action}`);
+      } catch (e) {
+        await updateDoc(cmdDoc.ref, {
+          status: "error",
+          error: e.message,
+          completedAt: new Date().toISOString()
+        });
+        log(`❌ 커맨드 실패: ${cmd.action} — ${e.message}`);
+      }
+    }
+  });
+}
+
+export function listenFirestore(db, uid, petId) {
+  // pet config 변경 리스너
+  const unsubPet = onSnapshot(doc(db, "users", uid, "pets", petId), async (snap) => {
+    if (!snap.exists() || skipRemoteWatch) return;
+    const data = snap.data();
+
+    // 폐기 감시
+    if (data.revoked) {
+      log("🚫 이 pet이 폐기되었습니다. 데몬 종료.");
+      process.exit(0);
+    }
+
+    // config 복호화 (암호화된 경우)
+    let config = data.config;
+    if (data.encryptedConfig) {
+      const decrypted = await decryptConfig(data.encryptedConfig);
+      if (decrypted) {
+        config = decrypted;
+        log("🔓 config 복호화 완료");
+      } else {
+        log("⚠️ config 복호화 실패, 로컬 변경 건너뜀");
+      }
+    }
+
+    // config 변경 감지
+    const hash = JSON.stringify(config || {});
+    const configChanged = hash !== lastRemoteHash && lastRemoteHash !== "";
+    lastRemoteHash = hash;
+
+    if (config) writeConfig(config);
+    if (data.openclawFiles) writeOpenclawDir(data.openclawFiles);
+    if (data.workspace) writeWorkspace(data.workspace);
+    log("⬇ Firestore → 로컬 동기화");
+
+    // 환경변수/시크릿 변경 시 → 복호화 포함 .env 쓰기 + 게이트웨이 재시작
+    const hasEnvChange = data.deviceEnvVars || data.deviceSecrets;
+    if (hasEnvChange && loadEnvSecretsCallback) {
+      loadEnvSecretsCallback().then(() => restartGateway()).catch((e) => {
+        log(`⚠️ 환경변수 로드 실패: ${e.message}`);
+        restartGateway();
+      });
+    } else if (configChanged) {
+      restartGateway();
+    }
+  }, (error) => {
+    log(`❌ Firestore 리스너 에러: ${error.message}`);
+  });
+
+  // 커맨드 리스너
+  const unsubCmd = listenCommands(db, uid, petId);
+
+  return () => { unsubPet(); unsubCmd(); };
+}
+
+export function watchLocal(db, uid, petId) {
+  const targets = [CONFIG_FILE];
+  if (fs.existsSync(CONFIG_DIR)) targets.push(CONFIG_DIR);
+  if (fs.existsSync(WORKSPACE_DIR)) {
+    // 워크스페이스 .md 파일들만 감시
+    for (const f of WORKSPACE_FILES) {
+      const fp = path.join(WORKSPACE_DIR, f);
+      if (fs.existsSync(fp)) targets.push(fp);
+    }
+  }
+  const watcher = watch(targets, {
+    ignoreInitial: true,
+    awaitWriteFinish: { stabilityThreshold: 300 }
+  });
+  const handler = () => {
+    if (skipLocalWatch) return;
+    log("📝 로컬 변경 감지");
+    pushToFirestore(db, uid, petId);
+  };
+  watcher.on("change", handler).on("add", handler);
+  return watcher;
+}

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "ohmypetbook",
+  "version": "1.0.0",
+  "description": "OhMyPetBook daemon — OpenClaw device sync agent",
+  "type": "module",
+  "main": "daemon.js",
+  "bin": {
+    "ohmypetbook": "./daemon.js"
+  },
+  "scripts": {
+    "start": "node daemon.js run",
+    "login": "node daemon.js login"
+  },
+  "keywords": ["openclaw", "ohmypetbook", "daemon", "iot", "device-sync"],
+  "author": "bdhwan",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/bdhwan/ohmypetbook-daemon.git"
+  },
+  "homepage": "https://ohmypetbook.com",
+  "engines": {
+    "node": ">=18"
+  },
+  "files": [
+    "daemon.js",
+    "lib/",
+    "README.md",
+    "LICENSE"
+  ],
+  "dependencies": {
+    "chokidar": "^4.0.3",
+    "firebase": "^11.4.0"
+  }
+}