@hackersbaby/plugin 0.5.0 → 0.5.2

package/dist/hooks/cursor/session-start.js

@@ -6,6 +6,9 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
 var __commonJS = (cb, mod) => function __require() {
   return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
@@ -26,6 +29,41 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
+// src/config.ts
+function sessionStateFile(source) {
+  return import_path.default.join(CONFIG_DIR, `active-session-${source}.json`);
+}
+function ensureConfigDir() {
+  if (!import_fs.default.existsSync(CONFIG_DIR)) {
+    import_fs.default.mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+}
+function loadConfig() {
+  try {
+    if (!import_fs.default.existsSync(CONFIG_FILE)) return null;
+    const raw = import_fs.default.readFileSync(CONFIG_FILE, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function saveConfig(config) {
+  ensureConfigDir();
+  import_fs.default.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2), "utf-8");
+}
+var import_fs, import_path, import_os, CONFIG_DIR, CONFIG_FILE, QUEUE_FILE;
+var init_config = __esm({
+  "src/config.ts"() {
+    "use strict";
+    import_fs = __toESM(require("fs"));
+    import_path = __toESM(require("path"));
+    import_os = __toESM(require("os"));
+    CONFIG_DIR = import_path.default.join(import_os.default.homedir(), ".hackersbaby");
+    CONFIG_FILE = import_path.default.join(CONFIG_DIR, "config.json");
+    QUEUE_FILE = import_path.default.join(CONFIG_DIR, "queue.jsonl");
+  }
+});
+
 // ../shared/dist/types.js
 var require_types = __commonJS({
   "../shared/dist/types.js"(exports2) {
@@ -164,185 +202,175 @@ var require_dist = __commonJS({
   }
 });
 
-// src/collector.ts
-var import_uuid = require("uuid");
-
-// src/config.ts
-var import_fs = __toESM(require("fs"));
-var import_path = __toESM(require("path"));
-var import_os = __toESM(require("os"));
-var CONFIG_DIR = import_path.default.join(import_os.default.homedir(), ".hackersbaby");
-var CONFIG_FILE = import_path.default.join(CONFIG_DIR, "config.json");
-var QUEUE_FILE = import_path.default.join(CONFIG_DIR, "queue.jsonl");
-function sessionStateFile(source) {
-  return import_path.default.join(CONFIG_DIR, `active-session-${source}.json`);
-}
-function ensureConfigDir() {
-  if (!import_fs.default.existsSync(CONFIG_DIR)) {
-    import_fs.default.mkdirSync(CONFIG_DIR, { recursive: true });
-  }
-}
-function loadConfig() {
-  try {
-    if (!import_fs.default.existsSync(CONFIG_FILE)) return null;
-    const raw = import_fs.default.readFileSync(CONFIG_FILE, "utf-8");
-    return JSON.parse(raw);
-  } catch {
-    return null;
-  }
-}
-function saveConfig(config) {
-  ensureConfigDir();
-  import_fs.default.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2), "utf-8");
-}
-
 // src/api-client.ts
-var import_shared = __toESM(require_dist());
-var APIClient = class {
-  config = loadConfig();
-  sessionSecret = null;
-  chainHash = "0000000000000000";
-  get headers() {
-    return {
-      "Content-Type": "application/json",
-      Authorization: `Bearer ${this.config?.token || ""}`
-    };
-  }
-  /** Register session with server and get cryptographic secret */
-  async startSession(sessionId) {
-    try {
-      const server = this.config?.server || "https://hackers.baby";
-      const res = await fetch(`${server}/api/sessions/start`, {
-        method: "POST",
-        headers: this.headers,
-        body: JSON.stringify({ session_id: sessionId })
-      });
-      if (res.ok) {
-        const data = await res.json();
-        this.sessionSecret = data.session_secret;
-        this.chainHash = data.initial_chain_hash;
-        return true;
+var import_shared, APIClient;
+var init_api_client = __esm({
+  "src/api-client.ts"() {
+    "use strict";
+    init_config();
+    import_shared = __toESM(require_dist());
+    APIClient = class {
+      config = loadConfig();
+      sessionSecret = null;
+      chainHash = "0000000000000000";
+      onChainUpdate = null;
+      /** Set callback to persist chain state between hook processes */
+      setChainUpdateCallback(cb) {
+        this.onChainUpdate = cb;
       }
-      return false;
-    } catch {
-      return false;
-    }
-  }
-  async sendBatch(batch) {
-    try {
-      const server = this.config?.server || "https://hackers.baby";
-      if (this.sessionSecret) {
-        const prevChainHash = this.chainHash;
-        const newChainHash = (0, import_shared.computeChainHash)(batch.events, prevChainHash);
-        const signature = (0, import_shared.signBatch)(batch.session_id, batch.events, newChainHash, this.sessionSecret);
-        batch.signature = signature;
-        batch.chain_hash = newChainHash;
-        batch.prev_chain_hash = prevChainHash;
-        this.chainHash = newChainHash;
+      /** Restore crypto state from a previous session */
+      restoreCryptoState(secret, chainHash) {
+        this.sessionSecret = secret;
+        this.chainHash = chainHash;
       }
-      const res = await fetch(`${server}/api/scores/batch`, {
-        method: "POST",
-        headers: this.headers,
-        body: JSON.stringify(batch)
-      });
-      return res.ok;
-    } catch {
-      return false;
-    }
-  }
-  async refreshTokenIfNeeded() {
-    if (!this.config) return;
-    try {
-      const parts = this.config.token.split(".");
-      if (parts.length !== 3) return;
-      const payload = JSON.parse(Buffer.from(parts[1], "base64").toString("utf-8"));
-      const expMs = payload.exp * 1e3;
-      const oneDayMs = 24 * 60 * 60 * 1e3;
-      if (Date.now() + oneDayMs < expMs) return;
-      const res = await fetch(`${this.config.server}/api/auth/cli-token/refresh`, {
-        method: "POST",
-        headers: this.headers,
-        body: JSON.stringify({ refresh_token: this.config.refresh_token })
-      });
-      if (res.ok) {
-        const data = await res.json();
-        if (data.token) {
-          this.config.token = data.token;
-          if (data.refresh_token) this.config.refresh_token = data.refresh_token;
-          saveConfig(this.config);
+      get headers() {
+        return {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${this.config?.token || ""}`
+        };
+      }
+      /** Get current crypto state for persistence */
+      getCryptoState() {
+        if (!this.sessionSecret) return null;
+        return { secret: this.sessionSecret, chainHash: this.chainHash };
+      }
+      /** Register session with server and get cryptographic secret */
+      async startSession(sessionId) {
+        try {
+          const server = this.config?.server || "https://hackers.baby";
+          const res = await fetch(`${server}/api/sessions/start`, {
+            method: "POST",
+            headers: this.headers,
+            body: JSON.stringify({ session_id: sessionId })
+          });
+          if (res.ok) {
+            const data = await res.json();
+            this.sessionSecret = data.session_secret;
+            this.chainHash = data.initial_chain_hash;
+            return true;
+          }
+          return false;
+        } catch {
+          return false;
         }
       }
-    } catch {
-    }
-  }
-  async getStatus() {
-    const server = this.config?.server || "https://hackers.baby";
-    const res = await fetch(`${server}/api/users/me`, { headers: this.headers });
-    if (!res.ok) throw new Error(`getStatus failed: ${res.status}`);
-    return res.json();
-  }
-  async getRank() {
-    const server = this.config?.server || "https://hackers.baby";
-    const res = await fetch(`${server}/api/users/me/rank`, { headers: this.headers });
-    if (!res.ok) throw new Error(`getRank failed: ${res.status}`);
-    return res.json();
-  }
-  async getLeaderboard() {
-    const server = this.config?.server || "https://hackers.baby";
-    const res = await fetch(`${server}/api/leaderboard/global?limit=10`, { headers: this.headers });
-    if (!res.ok) throw new Error(`getLeaderboard failed: ${res.status}`);
-    return res.json();
-  }
-  async getPublicStats() {
-    try {
-      const server = this.config?.server || "https://hackers.baby";
-      const res = await fetch(`${server}/api/stats/public`);
-      if (!res.ok) return null;
-      return res.json();
-    } catch {
-      return null;
-    }
-  }
-  async getNotifications() {
-    try {
-      const server = this.config?.server || "https://hackers.baby";
-      const res = await fetch(`${server}/api/users/me/notifications`, { headers: this.headers });
-      if (!res.ok) return null;
-      return res.json();
-    } catch {
-      return null;
-    }
-  }
-  async claimReferral(code) {
-    try {
-      const server = this.config?.server || "https://hackers.baby";
-      const res = await fetch(`${server}/api/referral/claim`, {
-        method: "POST",
-        headers: this.headers,
-        body: JSON.stringify({ referral_code: code })
-      });
-      if (!res.ok) return null;
-      return res.json();
-    } catch {
-      return null;
-    }
-  }
-  async getReferralStats() {
-    try {
-      const server = this.config?.server || "https://hackers.baby";
-      const res = await fetch(`${server}/api/referral/stats`, { headers: this.headers });
-      if (!res.ok) return null;
-      return res.json();
-    } catch {
-      return null;
-    }
+      async sendBatch(batch) {
+        try {
+          const server = this.config?.server || "https://hackers.baby";
+          if (this.sessionSecret) {
+            const prevChainHash = this.chainHash;
+            const newChainHash = (0, import_shared.computeChainHash)(batch.events, prevChainHash);
+            const signature = (0, import_shared.signBatch)(batch.session_id, batch.events, newChainHash, this.sessionSecret);
+            batch.signature = signature;
+            batch.chain_hash = newChainHash;
+            batch.prev_chain_hash = prevChainHash;
+            this.chainHash = newChainHash;
+            if (this.onChainUpdate) {
+              this.onChainUpdate(this.chainHash, this.sessionSecret);
+            }
+          }
+          const res = await fetch(`${server}/api/scores/batch`, {
+            method: "POST",
+            headers: this.headers,
+            body: JSON.stringify(batch)
+          });
+          return res.ok;
+        } catch {
+          return false;
+        }
+      }
+      async refreshTokenIfNeeded() {
+        if (!this.config) return;
+        try {
+          const parts = this.config.token.split(".");
+          if (parts.length !== 3) return;
+          const payload = JSON.parse(Buffer.from(parts[1], "base64").toString("utf-8"));
+          const expMs = payload.exp * 1e3;
+          const oneDayMs = 24 * 60 * 60 * 1e3;
+          if (Date.now() + oneDayMs < expMs) return;
+          const res = await fetch(`${this.config.server}/api/auth/cli-token/refresh`, {
+            method: "POST",
+            headers: this.headers,
+            body: JSON.stringify({ refresh_token: this.config.refresh_token })
+          });
+          if (res.ok) {
+            const data = await res.json();
+            if (data.token) {
+              this.config.token = data.token;
+              if (data.refresh_token) this.config.refresh_token = data.refresh_token;
+              saveConfig(this.config);
+            }
+          }
+        } catch {
+        }
+      }
+      async getStatus() {
+        const server = this.config?.server || "https://hackers.baby";
+        const res = await fetch(`${server}/api/users/me`, { headers: this.headers });
+        if (!res.ok) throw new Error(`getStatus failed: ${res.status}`);
+        return res.json();
+      }
+      async getRank() {
+        const server = this.config?.server || "https://hackers.baby";
+        const res = await fetch(`${server}/api/users/me/rank`, { headers: this.headers });
+        if (!res.ok) throw new Error(`getRank failed: ${res.status}`);
+        return res.json();
+      }
+      async getLeaderboard() {
+        const server = this.config?.server || "https://hackers.baby";
+        const res = await fetch(`${server}/api/leaderboard/global?limit=10`, { headers: this.headers });
+        if (!res.ok) throw new Error(`getLeaderboard failed: ${res.status}`);
+        return res.json();
+      }
+      async getPublicStats() {
+        try {
+          const server = this.config?.server || "https://hackers.baby";
+          const res = await fetch(`${server}/api/stats/public`);
+          if (!res.ok) return null;
+          return res.json();
+        } catch {
+          return null;
+        }
+      }
+      async getNotifications() {
+        try {
+          const server = this.config?.server || "https://hackers.baby";
+          const res = await fetch(`${server}/api/users/me/notifications`, { headers: this.headers });
+          if (!res.ok) return null;
+          return res.json();
+        } catch {
+          return null;
+        }
+      }
+      async claimReferral(code) {
+        try {
+          const server = this.config?.server || "https://hackers.baby";
+          const res = await fetch(`${server}/api/referral/claim`, {
+            method: "POST",
+            headers: this.headers,
+            body: JSON.stringify({ referral_code: code })
+          });
+          if (!res.ok) return null;
+          return res.json();
+        } catch {
+          return null;
+        }
+      }
+      async getReferralStats() {
+        try {
+          const server = this.config?.server || "https://hackers.baby";
+          const res = await fetch(`${server}/api/referral/stats`, { headers: this.headers });
+          if (!res.ok) return null;
+          return res.json();
+        } catch {
+          return null;
+        }
+      }
+    };
   }
-};
+});
 
 // src/queue.ts
-var import_fs2 = __toESM(require("fs"));
-var MAX_QUEUE_SIZE = 1e4;
-var MAX_AGE_MS = 24 * 60 * 60 * 1e3;
 function enqueueEvents(events) {
   ensureConfigDir();
   const lines = events.map((e) => JSON.stringify(e)).join("\n");
@@ -380,82 +408,158 @@ function drainQueue() {
     return [];
   }
 }
+var import_fs2, MAX_QUEUE_SIZE, MAX_AGE_MS;
+var init_queue = __esm({
+  "src/queue.ts"() {
+    "use strict";
+    import_fs2 = __toESM(require("fs"));
+    init_config();
+    MAX_QUEUE_SIZE = 1e4;
+    MAX_AGE_MS = 24 * 60 * 60 * 1e3;
+  }
+});
 
 // src/collector.ts
-var EventCollector = class {
-  sessionId;
-  buffer = [];
-  flushInterval = null;
-  client;
-  source;
-  constructor(sessionId, source) {
-    this.sessionId = sessionId ?? (0, import_uuid.v4)();
-    this.client = new APIClient();
-    this.source = source;
-  }
-  addEvent(event) {
-    const metadata = this.source ? { ...event.metadata, source: this.source } : event.metadata;
-    this.buffer.push({
-      ...event,
-      metadata,
-      timestamp: (/* @__PURE__ */ new Date()).toISOString()
-    });
-  }
-  async start() {
-    await this.client.refreshTokenIfNeeded();
-    await this.client.startSession(this.sessionId);
-    const queued = drainQueue();
-    if (queued.length > 0) {
-      const batch = { session_id: this.sessionId, events: queued };
-      const ok = await this.client.sendBatch(batch);
-      if (!ok) {
-        enqueueEvents(queued);
+var import_uuid, EventCollector;
+var init_collector = __esm({
+  "src/collector.ts"() {
+    "use strict";
+    import_uuid = require("uuid");
+    init_api_client();
+    init_queue();
+    init_config();
+    EventCollector = class {
+      sessionId;
+      buffer = [];
+      flushInterval = null;
+      client;
+      source;
+      constructor(sessionId, source) {
+        this.sessionId = sessionId ?? (0, import_uuid.v4)();
+        this.client = new APIClient();
+        this.source = source;
       }
-    }
-    const config = loadConfig();
-    const intervalMs = config?.preferences?.batch_interval_ms ?? 1e4;
-    this.flushInterval = setInterval(() => {
-      this.flush().catch(() => {
-      });
-    }, intervalMs);
-  }
-  async flush() {
-    if (this.buffer.length === 0) return;
-    const events = this.buffer.splice(0);
-    const batch = { session_id: this.sessionId, events };
-    const ok = await this.client.sendBatch(batch);
-    if (!ok) {
-      enqueueEvents(events);
-    }
-  }
-  async stop() {
-    if (this.flushInterval !== null) {
-      clearInterval(this.flushInterval);
-      this.flushInterval = null;
-    }
-    this.addEvent({ action_type: "session_completed", value: 1, metadata: {} });
-    await this.flush();
+      /** Restore crypto state from persisted session data */
+      restoreCrypto(secret, chainHash) {
+        this.client.restoreCryptoState(secret, chainHash);
+      }
+      /** Set callback to persist crypto state after each batch */
+      setCryptoUpdateCallback(cb) {
+        this.client.setChainUpdateCallback(cb);
+      }
+      addEvent(event) {
+        const metadata = this.source ? { ...event.metadata, source: this.source } : event.metadata;
+        this.buffer.push({
+          ...event,
+          metadata,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        });
+      }
+      async start() {
+        await this.client.refreshTokenIfNeeded();
+        await this.client.startSession(this.sessionId);
+        const queued = drainQueue();
+        if (queued.length > 0) {
+          const batch = { session_id: this.sessionId, events: queued };
+          const ok = await this.client.sendBatch(batch);
+          if (!ok) {
+            enqueueEvents(queued);
+          }
+        }
+        const config = loadConfig();
+        const intervalMs = config?.preferences?.batch_interval_ms ?? 1e4;
+        this.flushInterval = setInterval(() => {
+          this.flush().catch(() => {
+          });
+        }, intervalMs);
+      }
+      async flush() {
+        if (this.buffer.length === 0) return;
+        const events = this.buffer.splice(0);
+        const batch = { session_id: this.sessionId, events };
+        const ok = await this.client.sendBatch(batch);
+        if (!ok) {
+          enqueueEvents(events);
+        }
+      }
+      async stop() {
+        if (this.flushInterval !== null) {
+          clearInterval(this.flushInterval);
+          this.flushInterval = null;
+        }
+        this.addEvent({ action_type: "session_completed", value: 1, metadata: {} });
+        await this.flush();
+      }
+    };
   }
-};
+});
+
+// src/hooks/shared/session-start.ts
+init_collector();
+init_api_client();
+init_config();
 
 // src/hooks/shared/utils.ts
 var import_fs3 = __toESM(require("fs"));
+init_config();
 function saveSessionState(state) {
   const file = sessionStateFile(state.source);
   import_fs3.default.writeFileSync(file, JSON.stringify(state));
 }
+function readStdin() {
+  return new Promise((resolve) => {
+    let input = "";
+    process.stdin.on("data", (chunk) => {
+      input += chunk;
+    });
+    process.stdin.on("end", () => resolve(input));
+  });
+}
 function detectSource(payload) {
   if (process.env.CURSOR_VERSION) return "cursor";
   if (payload?.cursor_version) return "cursor";
   return "claude";
 }
+function normalizePayload(source, raw) {
+  if (source === "cursor") {
+    return { ...raw };
+  }
+  return raw;
+}
 
 // src/hooks/shared/session-start.ts
 async function handleSessionStart(source) {
+  let payloadSessionId;
+  try {
+    const input = await readStdin();
+    const raw = JSON.parse(input);
+    const detected2 = detectSource(raw);
+    const hookData = normalizePayload(detected2, raw);
+    if (typeof hookData.session_id === "string" && hookData.session_id.length > 0) {
+      payloadSessionId = hookData.session_id;
+    }
+  } catch {
+  }
   const detected = detectSource();
-  const collector = new EventCollector(void 0, detected);
+  const collector = new EventCollector(payloadSessionId, detected);
+  collector.setCryptoUpdateCallback((chainHash, secret) => {
+    saveSessionState({
+      sessionId: collector.sessionId,
+      pid: process.pid,
+      source: detected,
+      sessionSecret: secret,
+      chainHash
+    });
+  });
   await collector.start();
-  saveSessionState({ sessionId: collector.sessionId, pid: process.pid, source: detected });
+  const crypto = collector.client.getCryptoState();
+  saveSessionState({
+    sessionId: collector.sessionId,
+    pid: process.pid,
+    source: detected,
+    sessionSecret: crypto?.secret,
+    chainHash: crypto?.chainHash
+  });
   try {
     const config = loadConfig();
     if (config?.token) {