botsync 0.2.0 → 0.2.1

package/dist/commands/stop.js

@@ -40,8 +40,10 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.stop = stop;
 const syncthing_js_1 = require("../syncthing.js");
+const heartbeat_js_1 = require("../heartbeat.js");
 const ui = __importStar(require("../ui.js"));
 async function stop() {
+    (0, heartbeat_js_1.stopHeartbeat)();
     const killed = (0, syncthing_js_1.stopDaemon)();
     if (killed) {
         ui.stopped();

package/dist/heartbeat-daemon.d.ts

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+/**
+ * heartbeat-daemon.ts — Standalone background heartbeat process.
+ *
+ * Spawned as a detached child by init/join. Sends heartbeats every 60s
+ * until the Syncthing daemon dies (checked via API ping), then exits.
+ *
+ * Usage: node heartbeat-daemon.js
+ * (Not meant to be run directly — spawned by init/join)
+ */
+export {};

package/dist/heartbeat-daemon.js

@@ -0,0 +1,99 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * heartbeat-daemon.ts — Standalone background heartbeat process.
+ *
+ * Spawned as a detached child by init/join. Sends heartbeats every 60s
+ * until the Syncthing daemon dies (checked via API ping), then exits.
+ *
+ * Usage: node heartbeat-daemon.js
+ * (Not meant to be run directly — spawned by init/join)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const os_1 = require("os");
+const config_js_1 = require("./config.js");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const RELAY_URL = "https://relay.botsync.io";
+const HEARTBEAT_INTERVAL_MS = 60_000;
+const HEALTH_CHECK_INTERVAL_MS = 120_000; // Check if Syncthing is alive every 2 min
+const PID_FILE = (0, path_1.join)(config_js_1.BOTSYNC_DIR, "heartbeat.pid");
+function getVersion() {
+    try {
+        return require("../package.json").version || "0.0.0";
+    }
+    catch {
+        return "0.0.0";
+    }
+}
+async function sendHeartbeat() {
+    const config = (0, config_js_1.readConfig)();
+    const networkId = (0, config_js_1.readNetworkId)();
+    if (!config?.deviceId || !networkId)
+        return false;
+    try {
+        const res = await fetch(`${RELAY_URL}/network/${encodeURIComponent(networkId)}/heartbeat`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+                deviceId: config.deviceId,
+                name: (0, os_1.hostname)(),
+                os: process.platform,
+                version: getVersion(),
+            }),
+            signal: AbortSignal.timeout(5000),
+        });
+        return res.ok;
+    }
+    catch {
+        return false;
+    }
+}
+async function isSyncthingAlive() {
+    const config = (0, config_js_1.readConfig)();
+    if (!config)
+        return false;
+    try {
+        const res = await fetch(`http://127.0.0.1:${config.apiPort}/rest/system/ping`, {
+            headers: { "X-API-Key": config.apiKey },
+            signal: AbortSignal.timeout(3000),
+        });
+        return res.ok;
+    }
+    catch {
+        return false;
+    }
+}
+async function main() {
+    // Write our PID so stop can kill us
+    (0, fs_1.writeFileSync)(PID_FILE, String(process.pid));
+    // Cleanup PID file on exit
+    const cleanup = () => {
+        try {
+            (0, fs_1.unlinkSync)(PID_FILE);
+        }
+        catch { }
+    };
+    process.on("exit", cleanup);
+    process.on("SIGTERM", () => {
+        cleanup();
+        process.exit(0);
+    });
+    process.on("SIGINT", () => {
+        cleanup();
+        process.exit(0);
+    });
+    // Initial heartbeat
+    await sendHeartbeat();
+    // Heartbeat loop
+    setInterval(sendHeartbeat, HEARTBEAT_INTERVAL_MS);
+    // Health check loop — exit if Syncthing is gone
+    setInterval(async () => {
+        const alive = await isSyncthingAlive();
+        if (!alive) {
+            cleanup();
+            process.exit(0);
+        }
+    }, HEALTH_CHECK_INTERVAL_MS);
+}
+main().catch(() => process.exit(1));

package/dist/heartbeat.d.ts

@@ -1,14 +1,13 @@
 /**
- * heartbeat.ts — Periodic heartbeat to the botsync relay.
+ * heartbeat.ts — Spawn/stop the background heartbeat daemon.
  *
- * Sends device info every 60s so the dashboard at botsync.io/dashboard
- * can show connected devices. The relay stores each heartbeat in KV
- * with a 5-minute TTL — if we stop heartbeating, we disappear.
- *
- * The heartbeat runs in the background and never throws — a failed
- * heartbeat just means we're invisible on the dashboard for a cycle.
+ * Instead of running in-process (which dies when init/join exits),
+ * we spawn heartbeat-daemon.js as a detached child process that
+ * outlives the parent CLI command.
  */
-/** Start the heartbeat loop. Sends one immediately, then every 60s. */
+/** Spawn the heartbeat daemon as a detached background process. */
 export declare function startHeartbeat(): void;
-/** Stop the heartbeat loop. */
+/** Stop the heartbeat daemon if running. */
 export declare function stopHeartbeat(): void;
+/** Check if the heartbeat daemon is still alive. */
+export declare function isHeartbeatRunning(): boolean;

package/dist/heartbeat.js

@@ -1,73 +1,66 @@
 "use strict";
 /**
- * heartbeat.ts — Periodic heartbeat to the botsync relay.
+ * heartbeat.ts — Spawn/stop the background heartbeat daemon.
  *
- * Sends device info every 60s so the dashboard at botsync.io/dashboard
- * can show connected devices. The relay stores each heartbeat in KV
- * with a 5-minute TTL — if we stop heartbeating, we disappear.
- *
- * The heartbeat runs in the background and never throws — a failed
- * heartbeat just means we're invisible on the dashboard for a cycle.
+ * Instead of running in-process (which dies when init/join exits),
+ * we spawn heartbeat-daemon.js as a detached child process that
+ * outlives the parent CLI command.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.startHeartbeat = startHeartbeat;
 exports.stopHeartbeat = stopHeartbeat;
-const os_1 = require("os");
+exports.isHeartbeatRunning = isHeartbeatRunning;
+const child_process_1 = require("child_process");
+const fs_1 = require("fs");
+const path_1 = require("path");
 const config_js_1 = require("./config.js");
-const RELAY_URL = "https://relay.botsync.io";
-const HEARTBEAT_INTERVAL_MS = 60_000;
-let heartbeatTimer = null;
-/** Send a single heartbeat to the relay. */
-async function sendHeartbeat() {
-    const config = (0, config_js_1.readConfig)();
-    const networkId = (0, config_js_1.readNetworkId)();
-    if (!config?.deviceId || !networkId)
+const HEARTBEAT_PID_FILE = (0, path_1.join)(config_js_1.BOTSYNC_DIR, "heartbeat.pid");
+/** Spawn the heartbeat daemon as a detached background process. */
+function startHeartbeat() {
+    // Don't double-spawn
+    if (isHeartbeatRunning())
         return;
-    try {
-        await fetch(`${RELAY_URL}/network/${encodeURIComponent(networkId)}/heartbeat`, {
-            method: "POST",
-            headers: { "Content-Type": "application/json" },
-            body: JSON.stringify({
-                deviceId: config.deviceId,
-                name: (0, os_1.hostname)(),
-                os: process.platform,
-                version: getVersion(),
-            }),
-            signal: AbortSignal.timeout(5000),
-        });
-    }
-    catch {
-        // Silent fail — dashboard visibility is best-effort
-    }
+    const daemonScript = (0, path_1.join)((0, path_1.dirname)(__filename), "heartbeat-daemon.js");
+    const child = (0, child_process_1.spawn)(process.execPath, [daemonScript], {
+        detached: true,
+        stdio: "ignore",
+    });
+    child.unref();
 }
-/** Start the heartbeat loop. Sends one immediately, then every 60s. */
-function startHeartbeat() {
-    if (heartbeatTimer)
-        return; // Already running
-    // Fire immediately so the device shows up right away
-    sendHeartbeat();
-    heartbeatTimer = setInterval(sendHeartbeat, HEARTBEAT_INTERVAL_MS);
-    // Don't let the heartbeat timer keep the process alive if
-    // everything else is done (shouldn't happen since Syncthing
-    // daemon is the main keep-alive, but just in case)
-    if (heartbeatTimer.unref) {
-        heartbeatTimer.unref();
+/** Stop the heartbeat daemon if running. */
+function stopHeartbeat() {
+    const pid = getHeartbeatPid();
+    if (pid) {
+        try {
+            process.kill(pid, "SIGTERM");
+        }
+        catch {
+            // Already dead
+        }
     }
 }
-/** Stop the heartbeat loop. */
-function stopHeartbeat() {
-    if (heartbeatTimer) {
-        clearInterval(heartbeatTimer);
-        heartbeatTimer = null;
+/** Check if the heartbeat daemon is still alive. */
+function isHeartbeatRunning() {
+    const pid = getHeartbeatPid();
+    if (!pid)
+        return false;
+    try {
+        process.kill(pid, 0); // Signal 0 = just check if alive
+        return true;
+    }
+    catch {
+        return false;
     }
 }
-/** Read package version, fallback to 0.0.0 */
-function getVersion() {
+function getHeartbeatPid() {
     try {
-        const pkg = require("../package.json");
-        return pkg.version || "0.0.0";
+        if (!(0, fs_1.existsSync)(HEARTBEAT_PID_FILE))
+            return null;
+        const raw = (0, fs_1.readFileSync)(HEARTBEAT_PID_FILE, "utf-8").trim();
+        const pid = parseInt(raw, 10);
+        return isNaN(pid) ? null : pid;
     }
     catch {
-        return "0.0.0";
+        return null;
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "botsync",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "P2P file sync for AI agents. Syncthing under the hood. Two commands.",
   "bin": {
     "botsync": "dist/cli.js"