@blockrun/franklin 3.6.20 → 3.6.21

package/dist/agent/error-classifier.js

@@ -28,9 +28,12 @@ export function classifyAgentError(message) {
     if (includesAny(err, [
         '401',
         'unauthorized',
+        'unauthenticated',
+        'not authenticated',
         'invalid api key',
         'invalid x-api-key',
         'authentication failed',
+        'authentication required',
     ])) {
         return {
             category: 'auth', label: 'Auth', isTransient: false,

package/dist/commands/daemon.js

@@ -22,15 +22,24 @@ function isRunning(pid) {
     catch {
         return false;
     }
-    // PID may have been recycled to an unrelated process. Confirm the
-    // command line actually looks like Franklin before trusting the PID.
+    // PID may have been recycled. Try to confirm command line looks like Franklin.
+    // Platform fallbacks (some env lack `ps`): Linux /proc → ps → give up.
+    try {
+        // Linux (including Alpine/busybox containers) exposes /proc/<pid>/cmdline
+        const procCmdline = `/proc/${pid}/cmdline`;
+        if (fs.existsSync(procCmdline)) {
+            const raw = fs.readFileSync(procCmdline, 'utf-8').replace(/\0/g, ' ').trim();
+            return /franklin|runcode|node.*dist\/index/.test(raw);
+        }
+    }
+    catch { /* fall through to ps */ }
     try {
         const { execSync } = require('node:child_process');
         const cmd = execSync(`ps -p ${pid} -o command=`, { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'ignore'] }).trim();
         return /franklin|runcode|node.*dist\/index/.test(cmd);
     }
     catch {
-        // ps failed — fall back to assuming PID is ours (conservative, avoids false "running")
+        // No ps, no /proc — give up and trust the kill-0 check
         return true;
     }
 }

package/dist/commands/panel.js

@@ -5,13 +5,13 @@ import chalk from 'chalk';
 import { createPanelServer } from '../panel/server.js';
 export async function panelCommand(options) {
     const requestedPort = parseInt(options.port || '3100', 10);
-    // Handle port-in-use by trying up to 20 subsequent ports.
+    // Handle port-in-use by trying up to 20 subsequent ports silently.
+    // Only log when we finally bind (or fail completely) — no per-attempt spam.
     const MAX_ATTEMPTS = 20;
     const tryListen = (port, attempt) => {
         const server = createPanelServer(port);
         server.on('error', (err) => {
             if (err.code === 'EADDRINUSE' && attempt < MAX_ATTEMPTS) {
-                console.log(chalk.yellow(`  Port ${port} busy — trying ${port + 1}...`));
                 tryListen(port + 1, attempt + 1);
                 return;
             }
@@ -25,7 +25,8 @@ export async function panelCommand(options) {
         server.listen(port, () => {
             console.log('');
             console.log(chalk.bold('  Franklin Panel'));
-            console.log(chalk.dim(`  http://localhost:${port}`));
+            console.log(chalk.dim(`  http://localhost:${port}`) +
+                (port !== requestedPort ? chalk.yellow(`  (fell back from ${requestedPort})`) : ''));
             console.log('');
             console.log(chalk.dim('  Press Ctrl+C to stop.'));
             console.log('');

package/dist/session/storage.js

@@ -95,10 +95,27 @@ export function updateSessionMeta(sessionId, meta) {
         };
         // Atomic write: tmp file + rename. Prevents corruption when parent
         // and sub-agent update the same session meta concurrently.
+        // On Windows, renameSync can throw EEXIST/EPERM on older filesystems —
+        // fall back to a direct write (non-atomic but still functional) and
+        // clean up the orphan tmp file.
         const target = metaPath(sessionId);
         const tmp = target + '.tmp';
-        fs.writeFileSync(tmp, JSON.stringify(updated, null, 2));
-        fs.renameSync(tmp, target);
+        const payload = JSON.stringify(updated, null, 2);
+        try {
+            fs.writeFileSync(tmp, payload);
+            fs.renameSync(tmp, target);
+        }
+        catch {
+            // Best-effort: clean up the orphan tmp, then write target directly.
+            try {
+                fs.unlinkSync(tmp);
+            }
+            catch { /* may not exist */ }
+            try {
+                fs.writeFileSync(target, payload);
+            }
+            catch { /* give up; stats just get stale */ }
+        }
     });
 }
 /**

package/package.json

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