feat: follow mode switches to new log file after daemon restart

When `bitsocial logs -f` is running and the daemon restarts (e.g. via
`bitsocial update install`), the new daemon writes to a new timestamped
log file. Previously, follow mode kept watching the old file and missed
all output from the restarted daemon.

Add a 3-second polling interval that detects newer log files and
seamlessly switches the watcher, printing a separator to stderr.

Closes #31

Author: Rinse12

src/cli/commands/logs.ts

@@ -184,24 +184,26 @@ export default class Logs extends Command {
         }
 
         // Follow mode: dump existing content (filtered + tailed) then watch for new data
-        const existingContent = await fsPromise.readFile(latestLogFile, "utf-8");
+        let currentLogFile = latestLogFile;
+
+        const existingContent = await fsPromise.readFile(currentLogFile, "utf-8");
         const entries = this._parseLogEntries(existingContent);
         const filtered = this._filterEntries(entries, since, until);
         const streamFiltered = streamFilter ? this._filterByStream(filtered, streamFilter) : filtered;
         const tailed = this._tailEntries(streamFiltered, flags.tail);
         const initialOutput = tailed.map((e) => e.lines.join("\n")).join("\n");
         if (initialOutput) process.stdout.write(initialOutput + "\n");
 
-        const stat = await fsPromise.stat(latestLogFile);
+        const stat = await fsPromise.stat(currentLogFile);
         let position = stat.size;
         let pendingBuffer = "";
 
         // Watch for new data using polling (works across filesystems including Docker volumes)
         const readNewData = async () => {
             try {
-                const currentStat = await fsPromise.stat(latestLogFile);
+                const currentStat = await fsPromise.stat(currentLogFile);
                 if (currentStat.size > position) {
-                    const fd = await fsPromise.open(latestLogFile, "r");
+                    const fd = await fsPromise.open(currentLogFile, "r");
                     const buf = new Uint8Array(currentStat.size - position);
                     const { bytesRead } = await fd.read(buf, 0, buf.length, position);
                     await fd.close();
@@ -233,15 +235,68 @@ export default class Logs extends Command {
             }
         };
 
-        fs.watchFile(latestLogFile, { interval: 300 }, readNewData);
+        // Periodically check if a newer log file has appeared (e.g. after daemon restart)
+        const checkForNewLogFile = async () => {
+            try {
+                const newestFile = await this._findLatestLogFile(logPath);
+                if (newestFile === currentLogFile) return;
+
+                // Flush any remaining partial line from old file
+                if (pendingBuffer) {
+                    if (!since && !until && !streamFilter) {
+                        process.stdout.write(pendingBuffer + "\n");
+                    } else {
+                        const pbEntries = this._parseLogEntries(pendingBuffer);
+                        const pbFiltered = this._filterEntries(pbEntries, since, until);
+                        const pbStreamFiltered = streamFilter ? this._filterByStream(pbFiltered, streamFilter) : pbFiltered;
+                        const pbOutput = pbStreamFiltered.map((e) => e.lines.join("\n")).join("\n");
+                        if (pbOutput) process.stdout.write(pbOutput + "\n");
+                    }
+                }
+
+                // Switch watchers
+                fs.unwatchFile(currentLogFile, readNewData);
+                currentLogFile = newestFile;
+                pendingBuffer = "";
+
+                process.stderr.write(`\n--- switched to new log file: ${path.basename(newestFile)} ---\n\n`);
+
+                // Read and output entire new file content (with filters, no tail limit)
+                const newContent = await fsPromise.readFile(currentLogFile, "utf-8");
+                if (newContent) {
+                    if (!since && !until && !streamFilter) {
+                        process.stdout.write(newContent);
+                    } else {
+                        const newEntries = this._parseLogEntries(newContent.replace(/\n$/, ""));
+                        const filteredNew = this._filterEntries(newEntries, since, until);
+                        const streamFilteredNew = streamFilter
+                            ? this._filterByStream(filteredNew, streamFilter)
+                            : filteredNew;
+                        const output = streamFilteredNew.map((e) => e.lines.join("\n")).join("\n");
+                        if (output) process.stdout.write(output + "\n");
+                    }
+                }
+
+                const newStat = await fsPromise.stat(currentLogFile);
+                position = newStat.size;
+                fs.watchFile(currentLogFile, { interval: 300 }, readNewData);
+            } catch {
+                // Directory listing failed or file disappeared — retry next cycle
+            }
+        };
+
+        fs.watchFile(currentLogFile, { interval: 300 }, readNewData);
+        const newFileCheckInterval = setInterval(checkForNewLogFile, 3000);
 
         // Keep the process alive and clean up on exit
         process.on("SIGINT", () => {
-            fs.unwatchFile(latestLogFile, readNewData);
+            clearInterval(newFileCheckInterval);
+            fs.unwatchFile(currentLogFile, readNewData);
             process.exit(0);
         });
         process.on("SIGTERM", () => {
-            fs.unwatchFile(latestLogFile, readNewData);
+            clearInterval(newFileCheckInterval);
+            fs.unwatchFile(currentLogFile, readNewData);
             process.exit(0);
         });
 

test/cli/logs.test.ts

@@ -332,6 +332,135 @@ describe("bitsocial logs --stdout/--stderr filtering (synthetic)", () => {
     });
 });
 
+describe("bitsocial logs -f log file rotation (synthetic)", () => {
+    it("switches to new log file when one appears", async () => {
+        const { logDir } = await createLogDir();
+        const file1 = path.join(logDir, "bitsocial_cli_daemon_2026-03-01T00-00-00.000Z.log");
+        await fsPromise.writeFile(file1, buildLogLine(new Date("2026-03-01T00:00:00.000Z"), "INITIAL_MARKER") + "\n");
+
+        const result = await new Promise<{ stdout: string; stderr: string }>((resolve, reject) => {
+            const proc = spawn("node", ["./bin/run", "logs", "--logPath", logDir, "-f"], {
+                stdio: ["pipe", "pipe", "pipe"]
+            });
+
+            let stdout = "";
+            let stderr = "";
+            let createdNewFile = false;
+            proc.stdout.on("data", (data: Buffer) => {
+                stdout += data.toString();
+                // Wait for initial output before creating the new file
+                if (!createdNewFile && stdout.includes("INITIAL_MARKER")) {
+                    createdNewFile = true;
+                    const file2 = path.join(logDir, "bitsocial_cli_daemon_2026-03-01T01-00-00.000Z.log");
+                    fsPromise.writeFile(file2, buildLogLine(new Date("2026-03-01T01:00:00.000Z"), "NEW_FILE_MARKER") + "\n");
+                }
+            });
+            proc.stderr.on("data", (data: Buffer) => { stderr += data.toString(); });
+
+            // Wait long enough for the 3-second new-file check to fire, then kill
+            const timer = setTimeout(() => {
+                proc.kill("SIGINT");
+            }, 8000);
+
+            proc.on("close", () => {
+                clearTimeout(timer);
+                resolve({ stdout, stderr });
+            });
+            proc.on("error", (err) => {
+                clearTimeout(timer);
+                reject(err);
+            });
+        });
+
+        expect(result.stdout).toContain("INITIAL_MARKER");
+        expect(result.stdout).toContain("NEW_FILE_MARKER");
+        expect(result.stderr).toContain("switched to new log file");
+    });
+
+    it("applies --stdout filter after switching to new log file", async () => {
+        const { logDir } = await createLogDir();
+        const file1 = path.join(logDir, "bitsocial_cli_daemon_2026-04-01T00-00-00.000Z.log");
+        await fsPromise.writeFile(file1, buildLogLine(new Date("2026-04-01T00:00:00.000Z"), "initial stdout", "stdout") + "\n");
+
+        const result = await new Promise<{ stdout: string; stderr: string }>((resolve, reject) => {
+            const proc = spawn("node", ["./bin/run", "logs", "--logPath", logDir, "--stdout", "-f"], {
+                stdio: ["pipe", "pipe", "pipe"]
+            });
+
+            let stdout = "";
+            let stderr = "";
+            let createdNewFile = false;
+            proc.stdout.on("data", (data: Buffer) => {
+                stdout += data.toString();
+                if (!createdNewFile && stdout.includes("initial stdout")) {
+                    createdNewFile = true;
+                    const file2 = path.join(logDir, "bitsocial_cli_daemon_2026-04-01T01-00-00.000Z.log");
+                    const content = [
+                        buildLogLine(new Date("2026-04-01T01:00:00.000Z"), "new stdout msg", "stdout"),
+                        buildLogLine(new Date("2026-04-01T01:01:00.000Z"), "new stderr msg", "stderr")
+                    ].join("\n") + "\n";
+                    fsPromise.writeFile(file2, content);
+                }
+            });
+            proc.stderr.on("data", (data: Buffer) => { stderr += data.toString(); });
+
+            const timer = setTimeout(() => {
+                proc.kill("SIGINT");
+            }, 8000);
+
+            proc.on("close", () => {
+                clearTimeout(timer);
+                resolve({ stdout, stderr });
+            });
+            proc.on("error", (err) => {
+                clearTimeout(timer);
+                reject(err);
+            });
+        });
+
+        expect(result.stdout).toContain("initial stdout");
+        expect(result.stdout).toContain("new stdout msg");
+        expect(result.stdout).not.toContain("new stderr msg");
+    });
+
+    it("continues watching old file if no new file appears", async () => {
+        const { logDir } = await createLogDir();
+        const file1 = path.join(logDir, "bitsocial_cli_daemon_2026-05-01T00-00-00.000Z.log");
+        await fsPromise.writeFile(file1, buildLogLine(new Date("2026-05-01T00:00:00.000Z"), "initial line") + "\n");
+
+        const result = await new Promise<{ stdout: string }>((resolve, reject) => {
+            const proc = spawn("node", ["./bin/run", "logs", "--logPath", logDir, "-f"], {
+                stdio: ["pipe", "pipe", "pipe"]
+            });
+
+            let stdout = "";
+            proc.stdout.on("data", (data: Buffer) => { stdout += data.toString(); });
+
+            // Append to same file after a short delay
+            setTimeout(async () => {
+                await fsPromise.appendFile(file1, buildLogLine(new Date("2026-05-01T00:01:00.000Z"), "APPENDED_LINE") + "\n");
+            }, 500);
+
+            // Wait for the appended data to be picked up, then kill
+            const timer = setTimeout(() => {
+                proc.kill("SIGINT");
+            }, 2000);
+
+            proc.on("close", () => {
+                clearTimeout(timer);
+                resolve({ stdout });
+            });
+            proc.on("error", (err) => {
+                clearTimeout(timer);
+                reject(err);
+            });
+        });
+
+        expect(result.stdout).toContain("initial line");
+        expect(result.stdout).toContain("APPENDED_LINE");
+    });
+});
+
 describe("bitsocial logs (live daemon tests)", async () => {
     let daemonProcess: ManagedChildProcess;
     let logDir: string;