@blockrun/franklin 3.15.19 → 3.15.20

package/dist/commands/logs.js

@@ -3,17 +3,25 @@ import path from 'node:path';
 import chalk from 'chalk';
 import { BLOCKRUN_DIR } from '../config.js';
 const LOG_FILE = path.join(BLOCKRUN_DIR, 'franklin-debug.log');
+const ARCHIVE_LOG_FILE = path.join(BLOCKRUN_DIR, 'franklin-debug.log.1');
 const LEGACY_LOG_FILE = path.join(BLOCKRUN_DIR, 'runcode-debug.log');
-const MAX_LOG_SIZE = 10 * 1024 * 1024; // 10MB auto-rotate threshold
 export function logsCommand(options) {
     if (options.clear) {
+        let cleared = false;
         try {
             fs.unlinkSync(LOG_FILE);
-            console.log(chalk.green('Logs cleared.'));
+            cleared = true;
         }
-        catch {
-            console.log(chalk.dim('No log file to clear.'));
+        catch { /* may not exist */ }
+        try {
+            fs.unlinkSync(ARCHIVE_LOG_FILE);
+            cleared = true;
         }
+        catch { /* may not exist */ }
+        if (cleared)
+            console.log(chalk.green('Logs cleared.'));
+        else
+            console.log(chalk.dim('No log file to clear.'));
         return;
     }
     // Migrate legacy log file
@@ -23,23 +31,17 @@ export function logsCommand(options) {
         }
         catch { /* best effort */ }
     }
-    if (!fs.existsSync(LOG_FILE)) {
+    // Logger now self-rotates on write (in src/logger.ts). The previous
+    // in-place "slice off the first half" rotation here was destructive
+    // — every invocation that crossed 10 MB silently dropped half the
+    // history. With self-rotation in place this command no longer needs
+    // to mutate the file at all; it just stitches the archive + live
+    // log for display.
+    if (!fs.existsSync(LOG_FILE) && !fs.existsSync(ARCHIVE_LOG_FILE)) {
         console.log(chalk.dim('No logs yet. Start franklin with --debug to enable logging:'));
         console.log(chalk.bold('  franklin start --debug'));
         return;
     }
-    // Auto-rotate: if file is over threshold, keep only last half
-    try {
-        const stat = fs.statSync(LOG_FILE);
-        if (stat.size > MAX_LOG_SIZE) {
-            const content = fs.readFileSync(LOG_FILE, 'utf-8');
-            const lines = content.split('\n');
-            const half = lines.slice(Math.floor(lines.length / 2));
-            fs.writeFileSync(LOG_FILE, half.join('\n'));
-            console.log(chalk.dim(`(Rotated log — was ${(stat.size / 1024 / 1024).toFixed(1)}MB)`));
-        }
-    }
-    catch { /* ignore rotation errors */ }
     const parsed = parseInt(options.lines || '50', 10);
     const tailLines = isNaN(parsed) ? 50 : Math.max(1, Math.min(10000, parsed));
     if (options.follow) {
@@ -78,8 +80,15 @@ export function logsCommand(options) {
 }
 function printLastLines(n) {
     try {
-        const content = fs.readFileSync(LOG_FILE, 'utf-8');
-        const lines = content.split('\n').filter(Boolean);
+        // Logger self-rotates to franklin-debug.log.1 when the live log
+        // crosses 10MB. Stitch the archive on first so requests for "last N"
+        // can span the rotation boundary — without this, immediately after
+        // a rotation `franklin logs --lines 1000` would show only whatever
+        // lines have been written since rotation, even though the archive
+        // is sitting right next to it.
+        const archive = fs.existsSync(ARCHIVE_LOG_FILE) ? fs.readFileSync(ARCHIVE_LOG_FILE, 'utf-8') : '';
+        const live = fs.existsSync(LOG_FILE) ? fs.readFileSync(LOG_FILE, 'utf-8') : '';
+        const lines = (archive + live).split('\n').filter(Boolean);
         const start = Math.max(0, lines.length - n);
         const slice = lines.slice(start);
         if (start > 0) {

package/dist/logger.js

@@ -14,6 +14,20 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { BLOCKRUN_DIR } from './config.js';
 const LOG_FILE = path.join(BLOCKRUN_DIR, 'franklin-debug.log');
+const ARCHIVE_FILE = path.join(BLOCKRUN_DIR, 'franklin-debug.log.1');
+// Self-rotation threshold. When the live log crosses this size on a
+// write, rename it to franklin-debug.log.1 (overwriting any previous
+// archive) and start fresh. Non-destructive: one full archive of the
+// most recent ROTATE_AT_BYTES is always retained, so users can still
+// read history across the rotation. Earlier behavior (only triggered
+// by `franklin logs`, sliced the file in half in-place) lost history
+// outright and only ran if the user happened to invoke `franklin logs`.
+const ROTATE_AT_BYTES = 10 * 1024 * 1024; // 10 MB
+// Probe every N writes to amortize the stat() — average debug entry is
+// ~80 bytes, so 1000 writes (~80 KB worth) between checks keeps the
+// overhead negligible while still catching a runaway log within seconds.
+const ROTATE_PROBE_EVERY_N_WRITES = 1000;
+let writesSinceRotateProbe = 0;
 // Strip ANSI escapes + carriage returns so the log stays grep-able.
 const ANSI_RE = /\x1b\[[0-9;]*m|\x1b\][^\x07]*\x07|\r/g;
 let debugMode = false;
@@ -36,9 +50,42 @@ function ensureDir() {
     }
     catch { /* readonly mount / disk full — keep trying so a remount recovers */ }
 }
+function maybeRotate() {
+    try {
+        if (!fs.existsSync(LOG_FILE))
+            return;
+        const { size } = fs.statSync(LOG_FILE);
+        if (size < ROTATE_AT_BYTES)
+            return;
+        // renameSync overwrites an existing target on POSIX, which is what
+        // we want — single archive, always the most recent rotation. On
+        // Windows the rename can EEXIST; in that case unlink the archive
+        // first and retry. If even that fails, fall through silently rather
+        // than leaving the log file in a half-rotated state.
+        try {
+            fs.renameSync(LOG_FILE, ARCHIVE_FILE);
+        }
+        catch {
+            try {
+                fs.unlinkSync(ARCHIVE_FILE);
+            }
+            catch { /* may not exist */ }
+            try {
+                fs.renameSync(LOG_FILE, ARCHIVE_FILE);
+            }
+            catch { /* give up */ }
+        }
+    }
+    catch { /* best effort */ }
+}
 function writeFile(level, msg) {
     ensureDir();
     try {
+        writesSinceRotateProbe++;
+        if (writesSinceRotateProbe >= ROTATE_PROBE_EVERY_N_WRITES) {
+            writesSinceRotateProbe = 0;
+            maybeRotate();
+        }
         const clean = msg.replace(ANSI_RE, '');
         fs.appendFileSync(LOG_FILE, `[${new Date().toISOString()}] [${level.toUpperCase()}] ${clean}\n`);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blockrun/franklin",
-  "version": "3.15.19",
+  "version": "3.15.20",
   "description": "Franklin — The AI agent with a wallet. Spends USDC autonomously to get real work done. Pay per action, no subscriptions.",
   "type": "module",
   "exports": {