@kmmao/happy-agent 0.5.0 → 0.5.1

package/dist/index.cjs

@@ -17,8 +17,9 @@ var crypto = require('crypto');
 var path = require('path');
 var fs = require('fs');
 var os = require('os');
+var http = require('http');
 
-var version = "0.5.0";
+var version = "0.5.1";
 
 function loadConfig() {
   const serverUrl = (process.env.HAPPY_SERVER_URL ?? "https://happyserve.xycloud.info").replace(/\/+$/, "");
@@ -1838,12 +1839,15 @@ function isNotFound(err) {
 }
 
 const pidToSession = /* @__PURE__ */ new Map();
+let persistPath = null;
 function trackSession(session) {
   pidToSession.set(session.pid, session);
+  flush();
 }
 function untrackSession(pid) {
   const session = pidToSession.get(pid);
   pidToSession.delete(pid);
+  flush();
   return session;
 }
 function getTrackedSession(pid) {
@@ -1855,9 +1859,59 @@ function getAllTrackedSessions() {
 function getTrackedSessionCount() {
   return pidToSession.size;
 }
+function enablePersistence(filePath) {
+  persistPath = filePath;
+  load();
+}
+function load() {
+  if (!persistPath) return;
+  try {
+    const raw = fs.readFileSync(persistPath, "utf-8");
+    const entries = JSON.parse(raw);
+    let recovered = 0;
+    for (const entry of entries) {
+      try {
+        process.kill(entry.pid, 0);
+      } catch {
+        continue;
+      }
+      pidToSession.set(entry.pid, {
+        pid: entry.pid,
+        directory: entry.directory,
+        startedAt: entry.startedAt,
+        happySessionId: entry.happySessionId,
+        lastActivityAt: entry.lastActivityAt,
+        automationContext: entry.automationContext
+      });
+      recovered++;
+    }
+    if (recovered > 0) {
+      logger.debug(`[TRACKED] Recovered ${recovered} sessions from ${persistPath}`);
+    }
+  } catch {
+  }
+}
+function flush() {
+  if (!persistPath) return;
+  try {
+    const entries = [...pidToSession.values()].map((s) => ({
+      pid: s.pid,
+      directory: s.directory,
+      startedAt: s.startedAt,
+      happySessionId: s.happySessionId,
+      lastActivityAt: s.lastActivityAt,
+      automationContext: s.automationContext
+    }));
+    fs.mkdirSync(path.dirname(persistPath), { recursive: true });
+    fs.writeFileSync(persistPath, JSON.stringify(entries, null, 2), "utf-8");
+  } catch (err) {
+    logger.debug(`[TRACKED] Failed to persist: ${err}`);
+  }
+}
 
 var trackedSessions = /*#__PURE__*/Object.freeze({
   __proto__: null,
+  enablePersistence: enablePersistence,
   getAllTrackedSessions: getAllTrackedSessions,
   getTrackedSession: getTrackedSession,
   getTrackedSessionCount: getTrackedSessionCount,
@@ -3125,6 +3179,101 @@ class AutomationAuditStore {
   }
 }
 
+class WebhookServer {
+  server = null;
+  port = 0;
+  onSessionStarted = null;
+  /**
+   * Start the HTTP server on a random available port.
+   */
+  async start() {
+    return new Promise((resolve, reject) => {
+      this.server = http.createServer((req, res) => this.handleRequest(req, res));
+      this.server.on("error", (err) => {
+        logger.debug(`[WEBHOOK-SERVER] Error: ${err.message}`);
+        reject(err);
+      });
+      this.server.listen(0, "127.0.0.1", () => {
+        const addr = this.server.address();
+        if (addr && typeof addr === "object") {
+          this.port = addr.port;
+          logger.debug(`[WEBHOOK-SERVER] Listening on 127.0.0.1:${this.port}`);
+          resolve(this.port);
+        } else {
+          reject(new Error("Failed to get server address"));
+        }
+      });
+    });
+  }
+  /**
+   * Set the callback for session-started events.
+   */
+  setSessionStartedHandler(handler) {
+    this.onSessionStarted = handler;
+  }
+  /**
+   * Get the port the server is listening on.
+   */
+  getPort() {
+    return this.port;
+  }
+  /**
+   * Stop the server.
+   */
+  shutdown() {
+    if (this.server) {
+      this.server.close();
+      this.server = null;
+      logger.debug("[WEBHOOK-SERVER] Shutdown");
+    }
+  }
+  // -----------------------------------------------------------------------
+  // Internal
+  // -----------------------------------------------------------------------
+  handleRequest(req, res) {
+    if (req.method === "POST" && req.url === "/session-started") {
+      this.handleSessionStarted(req, res);
+      return;
+    }
+    if (req.method === "GET" && (req.url === "/" || req.url === "/health")) {
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ status: "ok", port: this.port }));
+      return;
+    }
+    res.writeHead(404);
+    res.end("Not Found");
+  }
+  handleSessionStarted(req, res) {
+    let body = "";
+    req.on("data", (chunk) => {
+      body += chunk.toString();
+    });
+    req.on("end", () => {
+      try {
+        const parsed = JSON.parse(body);
+        if (!parsed.sessionId || typeof parsed.sessionId !== "string") {
+          res.writeHead(400, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: "sessionId is required" }));
+          return;
+        }
+        const hostPid = typeof parsed.metadata?.hostPid === "number" ? parsed.metadata.hostPid : void 0;
+        logger.debug(`[WEBHOOK-SERVER] Session started: ${parsed.sessionId} (hostPid=${hostPid})`);
+        this.onSessionStarted?.(
+          parsed.sessionId,
+          parsed.metadata ?? {},
+          hostPid
+        );
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ status: "ok" }));
+      } catch (err) {
+        logger.debug(`[WEBHOOK-SERVER] Parse error: ${err}`);
+        res.writeHead(400, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: "Invalid JSON" }));
+      }
+    });
+  }
+}
+
 function pidFilePath(homeDir) {
   return node_path.join(homeDir, "agent-daemon.pid");
 }
@@ -3199,6 +3348,26 @@ async function startDaemon(options) {
   });
   const guardian = new GuardianSessionRegistry();
   const loopCoordinator = new AgentLoopCoordinator(scheduler, config.serverUrl, creds.token, guardian);
+  enablePersistence(node_path.join(config.homeDir, "agent-tracked-sessions.json"));
+  const webhookServer = new WebhookServer();
+  const webhookPort = await webhookServer.start();
+  webhookServer.setSessionStartedHandler((sessionId, _metadata, hostPid) => {
+    if (hostPid) {
+      const tracked = getTrackedSession(hostPid);
+      if (tracked) {
+        tracked.happySessionId = sessionId;
+        logger.debug(`[DAEMON] Session ${sessionId} linked to PID ${hostPid}`);
+        if (tracked.automationContext?.kind === "agent_loop") {
+          guardian.remember(sessionId, {
+            loopId: tracked.automationContext.trigger?.split(":")[1],
+            projectId: tracked.automationContext.projectId
+          });
+        }
+      }
+    }
+  });
+  process.env.HAPPY_DAEMON_HTTP_PORT = String(webhookPort);
+  console.log(`Webhook server: 127.0.0.1:${webhookPort}`);
   client.setTailscaleInfo(fullTailscale);
   client.enableAutomation(config.serverUrl, creds.token, scheduler, loopCoordinator, auditStore);
   loopCoordinator.start();
@@ -3212,6 +3381,7 @@ async function startDaemon(options) {
     logger.debug(`[DAEMON] Received ${signal}, shutting down...`);
     console.log(`
 Received ${signal}, shutting down...`);
+    webhookServer.shutdown();
     loopCoordinator.shutdown();
     scheduler.shutdown();
     client.shutdown();

package/dist/index.mjs

@@ -12,11 +12,12 @@ import { exec, execFile, spawn } from 'child_process';
 import { promisify } from 'util';
 import { readFile, mkdir, writeFile, readdir, stat } from 'fs/promises';
 import { createHash as createHash$1, randomUUID } from 'crypto';
-import { join as join$1, resolve } from 'path';
-import { realpathSync } from 'fs';
+import { join as join$1, resolve, dirname as dirname$1 } from 'path';
+import { realpathSync, readFileSync as readFileSync$1, mkdirSync as mkdirSync$1, writeFileSync as writeFileSync$1 } from 'fs';
 import { tmpdir } from 'os';
+import { createServer } from 'http';
 
-var version = "0.5.0";
+var version = "0.5.1";
 
 function loadConfig() {
   const serverUrl = (process.env.HAPPY_SERVER_URL ?? "https://happyserve.xycloud.info").replace(/\/+$/, "");
@@ -1836,12 +1837,15 @@ function isNotFound(err) {
 }
 
 const pidToSession = /* @__PURE__ */ new Map();
+let persistPath = null;
 function trackSession(session) {
   pidToSession.set(session.pid, session);
+  flush();
 }
 function untrackSession(pid) {
   const session = pidToSession.get(pid);
   pidToSession.delete(pid);
+  flush();
   return session;
 }
 function getTrackedSession(pid) {
@@ -1853,9 +1857,59 @@ function getAllTrackedSessions() {
 function getTrackedSessionCount() {
   return pidToSession.size;
 }
+function enablePersistence(filePath) {
+  persistPath = filePath;
+  load();
+}
+function load() {
+  if (!persistPath) return;
+  try {
+    const raw = readFileSync$1(persistPath, "utf-8");
+    const entries = JSON.parse(raw);
+    let recovered = 0;
+    for (const entry of entries) {
+      try {
+        process.kill(entry.pid, 0);
+      } catch {
+        continue;
+      }
+      pidToSession.set(entry.pid, {
+        pid: entry.pid,
+        directory: entry.directory,
+        startedAt: entry.startedAt,
+        happySessionId: entry.happySessionId,
+        lastActivityAt: entry.lastActivityAt,
+        automationContext: entry.automationContext
+      });
+      recovered++;
+    }
+    if (recovered > 0) {
+      logger.debug(`[TRACKED] Recovered ${recovered} sessions from ${persistPath}`);
+    }
+  } catch {
+  }
+}
+function flush() {
+  if (!persistPath) return;
+  try {
+    const entries = [...pidToSession.values()].map((s) => ({
+      pid: s.pid,
+      directory: s.directory,
+      startedAt: s.startedAt,
+      happySessionId: s.happySessionId,
+      lastActivityAt: s.lastActivityAt,
+      automationContext: s.automationContext
+    }));
+    mkdirSync$1(dirname$1(persistPath), { recursive: true });
+    writeFileSync$1(persistPath, JSON.stringify(entries, null, 2), "utf-8");
+  } catch (err) {
+    logger.debug(`[TRACKED] Failed to persist: ${err}`);
+  }
+}
 
 var trackedSessions = /*#__PURE__*/Object.freeze({
   __proto__: null,
+  enablePersistence: enablePersistence,
   getAllTrackedSessions: getAllTrackedSessions,
   getTrackedSession: getTrackedSession,
   getTrackedSessionCount: getTrackedSessionCount,
@@ -3123,6 +3177,101 @@ class AutomationAuditStore {
   }
 }
 
+class WebhookServer {
+  server = null;
+  port = 0;
+  onSessionStarted = null;
+  /**
+   * Start the HTTP server on a random available port.
+   */
+  async start() {
+    return new Promise((resolve, reject) => {
+      this.server = createServer((req, res) => this.handleRequest(req, res));
+      this.server.on("error", (err) => {
+        logger.debug(`[WEBHOOK-SERVER] Error: ${err.message}`);
+        reject(err);
+      });
+      this.server.listen(0, "127.0.0.1", () => {
+        const addr = this.server.address();
+        if (addr && typeof addr === "object") {
+          this.port = addr.port;
+          logger.debug(`[WEBHOOK-SERVER] Listening on 127.0.0.1:${this.port}`);
+          resolve(this.port);
+        } else {
+          reject(new Error("Failed to get server address"));
+        }
+      });
+    });
+  }
+  /**
+   * Set the callback for session-started events.
+   */
+  setSessionStartedHandler(handler) {
+    this.onSessionStarted = handler;
+  }
+  /**
+   * Get the port the server is listening on.
+   */
+  getPort() {
+    return this.port;
+  }
+  /**
+   * Stop the server.
+   */
+  shutdown() {
+    if (this.server) {
+      this.server.close();
+      this.server = null;
+      logger.debug("[WEBHOOK-SERVER] Shutdown");
+    }
+  }
+  // -----------------------------------------------------------------------
+  // Internal
+  // -----------------------------------------------------------------------
+  handleRequest(req, res) {
+    if (req.method === "POST" && req.url === "/session-started") {
+      this.handleSessionStarted(req, res);
+      return;
+    }
+    if (req.method === "GET" && (req.url === "/" || req.url === "/health")) {
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ status: "ok", port: this.port }));
+      return;
+    }
+    res.writeHead(404);
+    res.end("Not Found");
+  }
+  handleSessionStarted(req, res) {
+    let body = "";
+    req.on("data", (chunk) => {
+      body += chunk.toString();
+    });
+    req.on("end", () => {
+      try {
+        const parsed = JSON.parse(body);
+        if (!parsed.sessionId || typeof parsed.sessionId !== "string") {
+          res.writeHead(400, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: "sessionId is required" }));
+          return;
+        }
+        const hostPid = typeof parsed.metadata?.hostPid === "number" ? parsed.metadata.hostPid : void 0;
+        logger.debug(`[WEBHOOK-SERVER] Session started: ${parsed.sessionId} (hostPid=${hostPid})`);
+        this.onSessionStarted?.(
+          parsed.sessionId,
+          parsed.metadata ?? {},
+          hostPid
+        );
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ status: "ok" }));
+      } catch (err) {
+        logger.debug(`[WEBHOOK-SERVER] Parse error: ${err}`);
+        res.writeHead(400, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: "Invalid JSON" }));
+      }
+    });
+  }
+}
+
 function pidFilePath(homeDir) {
   return join(homeDir, "agent-daemon.pid");
 }
@@ -3197,6 +3346,26 @@ async function startDaemon(options) {
   });
   const guardian = new GuardianSessionRegistry();
   const loopCoordinator = new AgentLoopCoordinator(scheduler, config.serverUrl, creds.token, guardian);
+  enablePersistence(join(config.homeDir, "agent-tracked-sessions.json"));
+  const webhookServer = new WebhookServer();
+  const webhookPort = await webhookServer.start();
+  webhookServer.setSessionStartedHandler((sessionId, _metadata, hostPid) => {
+    if (hostPid) {
+      const tracked = getTrackedSession(hostPid);
+      if (tracked) {
+        tracked.happySessionId = sessionId;
+        logger.debug(`[DAEMON] Session ${sessionId} linked to PID ${hostPid}`);
+        if (tracked.automationContext?.kind === "agent_loop") {
+          guardian.remember(sessionId, {
+            loopId: tracked.automationContext.trigger?.split(":")[1],
+            projectId: tracked.automationContext.projectId
+          });
+        }
+      }
+    }
+  });
+  process.env.HAPPY_DAEMON_HTTP_PORT = String(webhookPort);
+  console.log(`Webhook server: 127.0.0.1:${webhookPort}`);
   client.setTailscaleInfo(fullTailscale);
   client.enableAutomation(config.serverUrl, creds.token, scheduler, loopCoordinator, auditStore);
   loopCoordinator.start();
@@ -3210,6 +3379,7 @@ async function startDaemon(options) {
     logger.debug(`[DAEMON] Received ${signal}, shutting down...`);
     console.log(`
 Received ${signal}, shutting down...`);
+    webhookServer.shutdown();
     loopCoordinator.shutdown();
     scheduler.shutdown();
     client.shutdown();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kmmao/happy-agent",
-  "version": "0.5.0",
+  "version": "0.5.1",
   "description": "CLI client for controlling Happy Coder agents remotely",
   "author": "Kirill Dubovitskiy",
   "license": "MIT",