@oss-autopilot/core 0.51.0 → 0.51.1

package/dist/commands/dashboard-server.js

@@ -165,7 +165,7 @@ export async function startDashboardServer(options) {
     // ── Rate limiters ───────────────────────────────────────────────────────
     const dataLimiter = new RateLimiter({ maxRequests: 30, windowMs: 60_000 }); // 30/min
     const actionLimiter = new RateLimiter({ maxRequests: 10, windowMs: 60_000 }); // 10/min
-    const refreshLimiter = new RateLimiter({ maxRequests: 2, windowMs: 60_000 }); // 2/min
+    const refreshLimiter = new RateLimiter({ maxRequests: 6, windowMs: 60_000 }); // 6/min
     // ── Request handler ──────────────────────────────────────────────────────
     const server = http.createServer(async (req, res) => {
         const method = req.method || 'GET';
@@ -179,6 +179,16 @@ export async function startDashboardServer(options) {
                     sendError(res, 429, 'Too many requests');
                     return;
                 }
+                // Re-read state.json if CLI commands modified it externally
+                if (stateManager.reloadIfChanged()) {
+                    try {
+                        cachedJsonData = buildDashboardJson(cachedDigest, stateManager.getState(), cachedCommentedIssues);
+                    }
+                    catch (error) {
+                        warn(MODULE, `Failed to rebuild dashboard data after state reload: ${errorMessage(error)}`);
+                        // Intentional: serve previous cachedJsonData rather than returning 500
+                    }
+                }
                 sendJson(res, 200, cachedJsonData);
                 return;
             }
@@ -227,6 +237,8 @@ export async function startDashboardServer(options) {
     server.requestTimeout = REQUEST_TIMEOUT_MS;
     // ── POST /api/action handler ─────────────────────────────────────────────
     async function handleAction(req, res) {
+        // Reload state before mutating to avoid overwriting external CLI changes
+        stateManager.reloadIfChanged();
         let body;
         try {
             const raw = await readBody(req);
@@ -293,6 +305,7 @@ export async function startDashboardServer(options) {
             return;
         }
         try {
+            stateManager.reloadIfChanged();
             warn(MODULE, 'Refreshing dashboard data from GitHub...');
             const result = await fetchDashboardData(currentToken);
             cachedDigest = result.digest;
@@ -408,6 +421,7 @@ export async function startDashboardServer(options) {
     if (token) {
         fetchDashboardData(token)
             .then((result) => {
+            stateManager.reloadIfChanged();
             cachedDigest = result.digest;
             cachedCommentedIssues = result.commentedIssues;
             cachedJsonData = buildDashboardJson(cachedDigest, stateManager.getState(), cachedCommentedIssues, result.allMergedPRs, result.allClosedPRs);

package/dist/core/state.d.ts

@@ -31,6 +31,7 @@ export declare function atomicWriteFileSync(filePath: string, data: string, mode
 export declare class StateManager {
     private state;
     private readonly inMemoryOnly;
+    private lastLoadedMtimeMs;
     /**
      * Create a new StateManager instance.
      * @param inMemoryOnly - When true, state is held only in memory and never read from or
@@ -92,6 +93,12 @@ export declare class StateManager {
      *   use the StateManager methods to make changes.
      */
     getState(): Readonly<AgentState>;
+    /**
+     * Re-read state from disk if the file has been modified since the last load/save.
+     * Uses mtime comparison (single statSync call) to avoid unnecessary JSON parsing.
+     * Returns true if state was reloaded, false if unchanged or in-memory mode.
+     */
+    reloadIfChanged(): boolean;
     /**
      * Store the latest daily digest for dashboard rendering.
      * @param digest - The freshly generated digest from the current daily run.

package/dist/core/state.js

@@ -169,6 +169,7 @@ function migrateV1ToV2(rawState) {
 export class StateManager {
     state;
     inMemoryOnly;
+    lastLoadedMtimeMs = 0;
     /**
      * Create a new StateManager instance.
      * @param inMemoryOnly - When true, state is held only in memory and never read from or
@@ -369,6 +370,13 @@ export class StateManager {
                     warn(MODULE, `Failed to clean up removed features from state: ${errorMessage(cleanupError)}`);
                     // Continue with loaded state — cleanup will be retried on next load
                 }
+                // Record file mtime so reloadIfChanged() can detect external writes
+                try {
+                    this.lastLoadedMtimeMs = fs.statSync(getStatePath()).mtimeMs;
+                }
+                catch (error) {
+                    debug(MODULE, `Could not read state file mtime (reload detection will always trigger): ${errorMessage(error)}`);
+                }
                 // Log appropriate message based on version
                 const repoCount = Object.keys(state.repoScores).length;
                 debug(MODULE, `Loaded state v${state.version}: ${repoCount} repo scores tracked`);
@@ -499,6 +507,8 @@ export class StateManager {
             }
             // Atomic write: write to temp file then rename to prevent corruption on crash
             atomicWriteFileSync(statePath, JSON.stringify(this.state, null, 2), 0o600);
+            // Update mtime so own writes don't trigger reloadIfChanged()
+            this.lastLoadedMtimeMs = fs.statSync(statePath).mtimeMs;
             debug(MODULE, 'State saved successfully');
         }
         finally {
@@ -535,6 +545,40 @@ export class StateManager {
     getState() {
         return this.state;
     }
+    /**
+     * Re-read state from disk if the file has been modified since the last load/save.
+     * Uses mtime comparison (single statSync call) to avoid unnecessary JSON parsing.
+     * Returns true if state was reloaded, false if unchanged or in-memory mode.
+     */
+    reloadIfChanged() {
+        if (this.inMemoryOnly)
+            return false;
+        try {
+            const statePath = getStatePath();
+            const currentMtimeMs = fs.statSync(statePath).mtimeMs;
+            if (currentMtimeMs === this.lastLoadedMtimeMs)
+                return false;
+            this.state = this.load();
+            // load() only records lastLoadedMtimeMs on the happy path. Ensure it is
+            // always current after reload (covers backup-restore and fresh-state paths)
+            // to prevent repeated unnecessary reloads on every request.
+            try {
+                this.lastLoadedMtimeMs = fs.statSync(statePath).mtimeMs;
+            }
+            catch {
+                // If file was just loaded, stat should not fail. If it does,
+                // next reloadIfChanged() will simply trigger another reload.
+            }
+            return true;
+        }
+        catch (error) {
+            // statSync failure (file deleted) is benign — keep current in-memory state.
+            // load() failure should not happen (load() handles its own recovery),
+            // but if it does, keeping current state is the safest option.
+            warn(MODULE, `Failed to reload state from disk: ${errorMessage(error)}`);
+            return false;
+        }
+    }
     /**
      * Store the latest daily digest for dashboard rendering.
      * @param digest - The freshly generated digest from the current daily run.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oss-autopilot/core",
-  "version": "0.51.0",
+  "version": "0.51.1",
   "description": "CLI and core library for managing open source contributions",
   "type": "module",
   "bin": {