itwillsync 1.3.8 → 1.5.2

package/dist/hub/daemon.js

@@ -3649,9 +3649,9 @@ var require_websocket_server = __commonJS({
 });
 
 // src/daemon.ts
-import { writeFileSync, mkdirSync, unlinkSync } from "fs";
-import { homedir } from "os";
-import { join as join2, dirname } from "path";
+import { writeFileSync as writeFileSync2, mkdirSync as mkdirSync2, unlinkSync, existsSync as existsSync2, readdirSync, statSync } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join3, dirname as dirname2 } from "path";
 import { fileURLToPath } from "url";
 
 // src/auth.ts
@@ -3721,7 +3721,39 @@ import { randomBytes as randomBytes2 } from "crypto";
 var SessionRegistry = class extends EventEmitter {
   sessions = /* @__PURE__ */ new Map();
   healthCheckInterval = null;
+  maxSessions;
+  store;
+  constructor(options = {}) {
+    super();
+    this.maxSessions = options.maxSessions ?? 20;
+    this.store = options.store ?? null;
+    if (this.store) {
+      const alive = this.store.loadAndMarkStale();
+      for (const s of alive) {
+        this.sessions.set(s.id, {
+          id: s.id,
+          name: s.name,
+          port: s.port,
+          token: s.token,
+          agent: s.agent,
+          cwd: s.cwd,
+          pid: s.pid,
+          connectedAt: s.connectedAt,
+          lastSeen: s.lastSeen,
+          status: s.status === "ended" ? "idle" : s.status
+        });
+      }
+    }
+  }
+  persistSessions() {
+    if (!this.store) return;
+    const sessions = this.getAll().map((s) => ({ ...s }));
+    this.store.save(sessions);
+  }
   register(registration) {
+    if (this.sessions.size >= this.maxSessions) {
+      throw new Error(`Maximum sessions reached (${this.maxSessions})`);
+    }
     const id = randomBytes2(8).toString("hex");
     const now = Date.now();
     const session = {
@@ -3733,12 +3765,14 @@ var SessionRegistry = class extends EventEmitter {
     };
     this.sessions.set(id, session);
     this.emit("session-added", session);
+    this.persistSessions();
     return session;
   }
   unregister(id) {
     const existed = this.sessions.delete(id);
     if (existed) {
       this.emit("session-removed", id);
+      this.persistSessions();
     }
     return existed;
   }
@@ -3772,6 +3806,7 @@ var SessionRegistry = class extends EventEmitter {
     if (session) {
       session.status = status;
       this.emit("session-updated", session);
+      this.persistSessions();
     }
   }
   /**
@@ -3814,6 +3849,80 @@ var SessionRegistry = class extends EventEmitter {
   }
 };
 
+// src/session-store.ts
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
+import { homedir } from "os";
+import { join, dirname } from "path";
+function getStorePath() {
+  const dir = process.env.ITWILLSYNC_CONFIG_DIR || join(homedir(), ".itwillsync");
+  return join(dir, "sessions.json");
+}
+var SessionStore = class {
+  savePending = false;
+  saveTimer = null;
+  sessions = [];
+  constructor() {
+    this.sessions = this.readFromDisk();
+  }
+  /** Load sessions from disk and mark stale ones (dead processes) as ended. */
+  loadAndMarkStale() {
+    for (const session of this.sessions) {
+      if (session.status === "ended") continue;
+      try {
+        process.kill(session.pid, 0);
+      } catch {
+        session.status = "ended";
+        session.lastSeen = Date.now();
+      }
+    }
+    const cutoff = Date.now() - 864e5;
+    this.sessions = this.sessions.filter(
+      (s) => s.status !== "ended" || s.lastSeen > cutoff
+    );
+    this.writeToDisk();
+    return this.sessions.filter((s) => s.status !== "ended");
+  }
+  /** Save current sessions (debounced 500ms). */
+  save(sessions) {
+    this.sessions = sessions;
+    if (this.saveTimer) return;
+    this.saveTimer = setTimeout(() => {
+      this.saveTimer = null;
+      this.writeToDisk();
+    }, 500);
+  }
+  /** Flush any pending save immediately. */
+  flush() {
+    if (this.saveTimer) {
+      clearTimeout(this.saveTimer);
+      this.saveTimer = null;
+    }
+    this.writeToDisk();
+  }
+  readFromDisk() {
+    const path = getStorePath();
+    if (!existsSync(path)) return [];
+    try {
+      const raw = readFileSync(path, "utf-8");
+      const data = JSON.parse(raw);
+      if (data.version !== 1 || !Array.isArray(data.sessions)) return [];
+      return data.sessions;
+    } catch {
+      return [];
+    }
+  }
+  writeToDisk() {
+    const path = getStorePath();
+    const dir = dirname(path);
+    mkdirSync(dir, { recursive: true });
+    const data = {
+      version: 1,
+      sessions: this.sessions
+    };
+    writeFileSync(path, JSON.stringify(data, null, 2) + "\n", "utf-8");
+  }
+};
+
 // src/internal-api.ts
 import { createServer } from "http";
 function createInternalApi(options) {
@@ -3858,7 +3967,14 @@ function createInternalApi(options) {
           res.end(JSON.stringify({ error: "Missing required fields: name, port, token, agent, pid" }));
           return;
         }
-        const session = registry.register(data);
+        let session;
+        try {
+          session = registry.register(data);
+        } catch (err) {
+          res.writeHead(503);
+          res.end(JSON.stringify({ error: err.message }));
+          return;
+        }
         res.writeHead(201);
         res.end(JSON.stringify({ session }));
         return;
@@ -3985,7 +4101,7 @@ function readBody(req) {
 // src/server.ts
 import { createServer as createServer2 } from "http";
 import { readFile } from "fs/promises";
-import { join, extname } from "path";
+import { join as join2, extname } from "path";
 import { gzipSync } from "zlib";
 
 // ../../node_modules/.pnpm/ws@8.19.0/node_modules/ws/wrapper.mjs
@@ -4058,7 +4174,7 @@ function createDashboardServer(options) {
     await serveStaticFile(dashboardPath, pathname, req, res);
   });
   async function serveStaticFile(basePath, filePath, req, res) {
-    const fullPath = join(basePath, filePath);
+    const fullPath = join2(basePath, filePath);
     const ext = extname(fullPath);
     const contentType = MIME_TYPES[ext] || "application/octet-stream";
     try {
@@ -4433,20 +4549,20 @@ var HUB_EXTERNAL_PORT = 7962;
 var HUB_INTERNAL_PORT = 7963;
 var AUTO_SHUTDOWN_DELAY_MS = 3e4;
 function getHubDir() {
-  return process.env.ITWILLSYNC_CONFIG_DIR || join2(homedir(), ".itwillsync");
+  return process.env.ITWILLSYNC_CONFIG_DIR || join3(homedir2(), ".itwillsync");
 }
 function getPidPath() {
-  return join2(getHubDir(), "hub.pid");
+  return join3(getHubDir(), "hub.pid");
 }
 function getHubConfigPath() {
-  return join2(getHubDir(), "hub.json");
+  return join3(getHubDir(), "hub.json");
 }
 async function main() {
   const hubDir = getHubDir();
-  mkdirSync(hubDir, { recursive: true });
+  mkdirSync2(hubDir, { recursive: true });
   const masterToken = generateToken();
   const startedAt = Date.now();
-  writeFileSync(getPidPath(), String(process.pid), "utf-8");
+  writeFileSync2(getPidPath(), String(process.pid), "utf-8");
   const hubConfig = {
     masterToken,
     externalPort: HUB_EXTERNAL_PORT,
@@ -4454,11 +4570,28 @@ async function main() {
     pid: process.pid,
     startedAt
   };
-  writeFileSync(getHubConfigPath(), JSON.stringify(hubConfig, null, 2) + "\n", "utf-8");
-  const registry = new SessionRegistry();
+  writeFileSync2(getHubConfigPath(), JSON.stringify(hubConfig, null, 2) + "\n", "utf-8");
+  const sessionStore = new SessionStore();
+  const registry = new SessionRegistry({ store: sessionStore });
   registry.startHealthChecks();
-  const __dirname = dirname(fileURLToPath(import.meta.url));
-  const dashboardPath = join2(__dirname, "dashboard");
+  const logsDir = join3(hubDir, "logs");
+  if (existsSync2(logsDir)) {
+    const retentionMs = 30 * 864e5;
+    const cutoff = Date.now() - retentionMs;
+    try {
+      for (const file of readdirSync(logsDir)) {
+        const filePath = join3(logsDir, file);
+        try {
+          const stat = statSync(filePath);
+          if (stat.mtimeMs < cutoff) unlinkSync(filePath);
+        } catch {
+        }
+      }
+    } catch {
+    }
+  }
+  const __dirname = dirname2(fileURLToPath(import.meta.url));
+  const dashboardPath = join3(__dirname, "dashboard");
   const internalApi = createInternalApi({
     registry,
     port: HUB_INTERNAL_PORT
@@ -4505,6 +4638,7 @@ async function main() {
   function cleanup() {
     previewCollector.close();
     registry.stopHealthChecks();
+    sessionStore.flush();
     registry.clear();
     internalApi.close();
     dashboardServer.close();