Merge pull request #2 from htlin222/claude/add-pid-lock-mechanism-FREK9

Author: htlin222

src/bot.ts

@@ -10,10 +10,12 @@ import { run, sequentialize } from "@grammyjs/runner";
 import { Bot } from "grammy";
 import {
 	ALLOWED_USERS,
+	PID_LOCK_FILE,
 	RESTART_FILE,
 	TELEGRAM_TOKEN,
 	WORKING_DIR,
 } from "./config";
+import { acquirePidLock, releasePidLock } from "./pid-lock";
 import {
 	handleBookmarks,
 	handleBranch,
@@ -139,6 +141,16 @@ bot.catch((err) => {
 	console.error("Bot error:", err);
 });
 
+// ============== PID Lock ==============
+
+const lockResult = acquirePidLock(PID_LOCK_FILE);
+if (!lockResult.acquired) {
+	console.error(
+		`Another instance is already running (PID ${lockResult.existingPid}). Exiting.`,
+	);
+	process.exit(1);
+}
+
 // ============== Startup ==============
 
 console.log("=".repeat(50));
@@ -221,12 +233,14 @@ const stopRunner = () => {
 
 process.on("SIGINT", () => {
 	console.log("Received SIGINT");
+	releasePidLock(PID_LOCK_FILE);
 	stopRunner();
 	process.exit(0);
 });
 
 process.on("SIGTERM", () => {
 	console.log("Received SIGTERM");
+	releasePidLock(PID_LOCK_FILE);
 	stopRunner();
 	process.exit(0);
 });

src/config.ts

@@ -342,6 +342,7 @@ const INSTANCE_TEMP_DIR = `/tmp/ctb-${INSTANCE_HASH}`;
 
 export const SESSION_FILE = `${INSTANCE_TEMP_DIR}/session.json`;
 export const RESTART_FILE = `${INSTANCE_TEMP_DIR}/restart.json`;
+export const PID_LOCK_FILE = `${INSTANCE_TEMP_DIR}/pid.lock`;
 export const TEMP_DIR = `${INSTANCE_TEMP_DIR}/downloads`;
 
 // Temp paths that are always allowed for bot operations

src/pid-lock.ts

@@ -0,0 +1,81 @@
+/**
+ * PID lock mechanism to prevent multiple bot instances from running simultaneously.
+ *
+ * When two instances poll the same Telegram bot token, both receive the same updates.
+ * In-process deduplication can't help across processes, so we use a PID lock file
+ * to ensure only one instance runs at a time.
+ */
+
+import { existsSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
+
+/**
+ * Check if a process with the given PID is currently running.
+ */
+function isProcessAlive(pid: number): boolean {
+	try {
+		// signal 0 doesn't kill the process, just checks if it exists
+		process.kill(pid, 0);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+export interface PidLockResult {
+	acquired: boolean;
+	/** The PID of the existing process if lock was not acquired */
+	existingPid?: number;
+}
+
+/**
+ * Try to acquire a PID lock file.
+ *
+ * - If no lock file exists, writes the current PID and returns success.
+ * - If a lock file exists with a dead process (stale lock), overwrites it.
+ * - If a lock file exists with a live process, returns failure with the existing PID.
+ */
+export function acquirePidLock(lockPath: string): PidLockResult {
+	const currentPid = process.pid;
+
+	if (existsSync(lockPath)) {
+		try {
+			const content = readFileSync(lockPath, "utf-8").trim();
+			const existingPid = Number.parseInt(content, 10);
+
+			if (!Number.isNaN(existingPid) && existingPid > 0) {
+				if (isProcessAlive(existingPid)) {
+					return { acquired: false, existingPid };
+				}
+				// Stale lock from a dead process - take over
+				console.log(
+					`Removing stale PID lock (PID ${existingPid} is no longer running)`,
+				);
+			}
+		} catch {
+			// Corrupted lock file - overwrite it
+			console.log("Removing corrupted PID lock file");
+		}
+	}
+
+	writeFileSync(lockPath, String(currentPid), "utf-8");
+	return { acquired: true };
+}
+
+/**
+ * Release the PID lock file. Only removes it if it contains our own PID
+ * (prevents accidentally removing a lock held by another process).
+ */
+export function releasePidLock(lockPath: string): void {
+	try {
+		if (!existsSync(lockPath)) return;
+
+		const content = readFileSync(lockPath, "utf-8").trim();
+		const lockedPid = Number.parseInt(content, 10);
+
+		if (lockedPid === process.pid) {
+			unlinkSync(lockPath);
+		}
+	} catch {
+		// Best-effort cleanup
+	}
+}