nightytidy 0.3.9 → 0.3.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nightytidy",
-  "version": "0.3.9",
+  "version": "0.3.10",
   "description": "Automated overnight codebase improvement through Claude Code",
   "license": "MIT",
   "author": "Dorian Spitz",

package/src/agent/index.js

@@ -723,6 +723,7 @@ export async function startAgent() {
           run: { id: run.id, progress: `${stepIndex + 1}/${totalSteps}`, costSoFar: stepData.cost, elapsedMs: stepData.duration },
         }, project.webhooks);
         stepIndex++;
+        runQueue.updateProgress({ ...runProgress });
       } else {
         const errorType = stepParsed.errorType;
         if (errorType === 'rate_limit') {
@@ -771,6 +772,7 @@ export async function startAgent() {
           run: { id: run.id },
         }, project.webhooks);
         stepIndex++;
+        runQueue.updateProgress({ ...runProgress });
       }
     }
 
@@ -959,6 +961,7 @@ export async function startAgent() {
           project: project.name, projectId: project.id, step: stepData,
           run: { id: interrupted.id, costSoFar: stepData.cost, elapsedMs: stepData.duration },
         }, project.webhooks);
+        runQueue.updateProgress({ ...runProgress });
       } else if (stepParsed.errorType === 'rate_limit') {
         const waitMs = stepParsed.retryAfterMs || 120000;
         info(`  ⏸ Rate limited — waiting ${Math.round(waitMs / 1000)}s`);
@@ -975,6 +978,7 @@ export async function startAgent() {
         const si = runProgress.stepList.findIndex(s => s.number === stepNum);
         if (si >= 0) Object.assign(runProgress.stepList[si], { status: 'completed' });
         wsServer.broadcast({ type: 'step-completed', runId: interrupted.id, step: { number: stepNum, status: 'completed', duration: 0, cost: 0 }, cost: 0 });
+        runQueue.updateProgress({ ...runProgress });
       } else {
         info(`  ✗ Step ${stepNum} failed: ${stepParsed.error || 'unknown'}`);
         runProgress.failedCount++;
@@ -985,6 +989,7 @@ export async function startAgent() {
           error: stepParsed.error || stepResult.stderr,
         });
         wsServer.broadcast({ type: 'step-failed', runId: interrupted.id, step: { number: stepNum }, error: stepParsed.error || stepResult.stderr });
+        runQueue.updateProgress({ ...runProgress });
       }
     }
 
@@ -1228,16 +1233,53 @@ export async function startAgent() {
   }
 
   // Also handle case where queue has a "running" entry from a crash
-  // (agent died without graceful shutdown, so markInterrupted was never called)
+  // (agent died without graceful shutdown, so markInterrupted was never called).
+  // Check for progress before discarding — force-kills may have left
+  // lastProgress from per-step updateProgress() calls, or the CLI state
+  // file may still exist in the target project.
   const current = runQueue.getCurrent();
   if (current && current.status === 'running' && !activeBridge) {
-    // Orphaned run with no progress — auto-discard instead of blocking the queue
-    info(`Found orphaned running run: ${current.id} — auto-discarding (0 steps completed)`);
-    runQueue.completeCurrent({ success: false });
-    dispatchWithQueue('run_failed', {
-      projectId: current.projectId,
-      run: { id: current.id },
-    }, []);
+    const savedProgress = current.lastProgress || {};
+    let completedFromQueue = savedProgress.completedCount || 0;
+
+    // Also check CLI state file as a fallback (belt + suspenders)
+    let completedFromCli = 0;
+    try {
+      const proj = projectManager.getProject(current.projectId);
+      if (proj) {
+        const stateFile = path.join(proj.path, 'nightytidy-run-state.json');
+        const state = JSON.parse(fs.readFileSync(stateFile, 'utf-8'));
+        completedFromCli = (state.completedSteps || []).length;
+      }
+    } catch { /* no state file — fine */ }
+
+    const totalCompleted = Math.max(completedFromQueue, completedFromCli);
+
+    if (totalCompleted === 0) {
+      // No work was done — safe to auto-discard
+      info(`Found orphaned running run: ${current.id} — auto-discarding (0 steps completed)`);
+      runQueue.completeCurrent({ success: false });
+      dispatchWithQueue('run_failed', {
+        projectId: current.projectId,
+        run: { id: current.id },
+      }, []);
+    } else {
+      // Has progress — transition to interrupted so user can resume/finish/discard
+      info(`Found orphaned running run: ${current.id} — transitioning to interrupted (${totalCompleted} steps completed)`);
+      const progress = Object.keys(savedProgress).length > 0
+        ? savedProgress
+        : { completedCount: completedFromCli, failedCount: 0, totalCost: 0 };
+      runQueue.markInterrupted(progress);
+      dispatchWithQueue('run_interrupted', {
+        projectId: current.projectId,
+        run: {
+          id: current.id,
+          totalSteps: current.steps?.length || 0,
+          completedSteps: totalCompleted,
+          elapsedMs: Date.now() - (current.startedAt || Date.now()),
+        },
+      }, []);
+    }
   }
 
   // Process any queued runs left from a previous session

package/src/agent/run-queue.js

@@ -56,6 +56,18 @@ export class RunQueue {
     }
   }
 
+  /**
+   * Persist run progress to disk so it survives force-kills and crashes.
+   * Called after each step completes/fails. The next startup can read
+   * current.lastProgress to recover the run.
+   */
+  updateProgress(progress) {
+    if (this.current) {
+      this.current.lastProgress = progress;
+      this._save();
+    }
+  }
+
   /**
    * Mark the current run as interrupted (agent shutting down mid-run).
    * Preserves progress data so the run can be resumed on restart.

package/src/agent/service.js

@@ -88,51 +88,111 @@ export function unregisterService() {
 // --- Platform implementations ---
 
 /**
- * Windows: Use the Startup folder (no admin needed).
- * Writes a .vbs wrapper script that launches the agent hidden (no console window).
- * Falls back to schtasks if Startup folder isn't writable.
+ * Windows: Write a .cmd launcher to ~/.nightytidy/ and register it with
+ * Task Scheduler (ONLOGON trigger). Task Scheduler is reliable on Windows 11
+ * where VBS scripts in the Startup folder are silently blocked by SmartScreen.
+ *
+ * The .cmd file uses `start /min` to avoid a visible console window.
+ * Falls back to the Startup folder VBS approach if schtasks fails.
  */
 const STARTUP_DIR = process.platform === 'win32'
   ? path.join(os.homedir(), 'AppData', 'Roaming', 'Microsoft', 'Windows', 'Start Menu', 'Programs', 'Startup')
   : '';
 const STARTUP_VBS = path.join(STARTUP_DIR, 'NightyTidy Agent.vbs');
+const AGENT_CMD = process.platform === 'win32'
+  ? path.join(os.homedir(), '.nightytidy', 'start-agent.cmd')
+  : '';
 
 function _registerWindows(cmd) {
-  // Primary: Startup folder (no admin required)
+  // Write a .cmd launcher script to ~/.nightytidy/start-agent.cmd
+  // Avoids quoting issues when passing to Task Scheduler or Startup folder.
+  const cmdContent = `@echo off\r\nstart /min "" ${cmd}\r\n`;
+  const cmdDir = path.dirname(AGENT_CMD);
+  fs.mkdirSync(cmdDir, { recursive: true });
+  fs.writeFileSync(AGENT_CMD, cmdContent, 'utf-8');
+  debug(`Wrote launcher script: ${AGENT_CMD}`);
+
+  // Primary: Task Scheduler via PowerShell (no admin required for user-level
+  // logon triggers). schtasks.exe /sc onlogon needs admin, but PowerShell's
+  // Register-ScheduledTask with a LogonTrigger does not.
+  try {
+    const escapedPath = AGENT_CMD.replace(/'/g, "''");
+    const ps = [
+      `$action = New-ScheduledTaskAction -Execute '${escapedPath}'`,
+      `$trigger = New-ScheduledTaskTrigger -AtLogOn`,
+      `$settings = New-ScheduledTaskSettingsSet -AllowStartIfOnBatteries -DontStopIfGoingOnBatteries -StartWhenAvailable`,
+      `Register-ScheduledTask -TaskName '${SERVICE_NAME}' -Action $action -Trigger $trigger -Settings $settings -Force`,
+    ].join('; ');
+    execSync(`powershell.exe -NoProfile -Command "${ps}"`, { stdio: 'pipe', timeout: 15000 });
+    debug('Registered via Task Scheduler (PowerShell)');
+    _removeStartupVbs();
+    return;
+  } catch (err) {
+    debug(`Task Scheduler failed: ${err.message}, trying Startup folder`);
+  }
+
+  // Fallback: Startup folder — place .cmd directly (less restricted than .vbs
+  // by Windows SmartScreen). The .cmd file runs the agent hidden via start /min.
   try {
-    // VBS wrapper runs the agent without showing a console window.
-    // In VBS, quotes inside strings are doubled: "" not \"
-    const vbsCmd = cmd.replace(/"/g, '""');
-    const vbs = `' NightyTidy Agent - auto-start on login\r\nSet ws = CreateObject("WScript.Shell")\r\nws.Run "${vbsCmd}", 0, False\r\n`;
     fs.mkdirSync(STARTUP_DIR, { recursive: true });
-    fs.writeFileSync(STARTUP_VBS, vbs, 'utf-8');
-    debug('Registered via Windows Startup folder');
+    const startupCmd = path.join(STARTUP_DIR, 'NightyTidy Agent.cmd');
+    fs.copyFileSync(AGENT_CMD, startupCmd);
+    debug('Registered via Startup folder (.cmd)');
+    _removeStartupVbs();
     return;
   } catch (err) {
-    debug(`Startup folder failed: ${err.message}, trying schtasks`);
+    debug(`Startup folder .cmd failed: ${err.message}, trying VBS`);
   }
 
-  // Fallback: Task Scheduler (needs admin on some systems)
-  execSync(
-    `schtasks /create /tn "${SERVICE_NAME}" /tr "${cmd}" /sc onlogon /rl LIMITED /f`,
-    { stdio: 'pipe' },
-  );
+  // Last resort: Startup folder VBS wrapper
+  const vbsCmd = cmd.replace(/"/g, '""');
+  const vbs = `' NightyTidy Agent - auto-start on login\r\nSet ws = CreateObject("WScript.Shell")\r\nws.Run "${vbsCmd}", 0, False\r\n`;
+  fs.mkdirSync(STARTUP_DIR, { recursive: true });
+  fs.writeFileSync(STARTUP_VBS, vbs, 'utf-8');
+  debug('Registered via Windows Startup folder (VBS)');
 }
 
-function _unregisterWindows() {
-  // Remove Startup folder entry
+function _removeStartupVbs() {
   try {
     if (fs.existsSync(STARTUP_VBS)) {
       fs.unlinkSync(STARTUP_VBS);
-      debug('Removed Startup folder entry');
+      debug('Removed stale Startup folder VBS');
+    }
+  } catch { /* ignore */ }
+}
+
+function _unregisterWindows() {
+  // Remove Startup folder entries (VBS and .cmd)
+  _removeStartupVbs();
+  try {
+    const startupCmd = path.join(STARTUP_DIR, 'NightyTidy Agent.cmd');
+    if (fs.existsSync(startupCmd)) {
+      fs.unlinkSync(startupCmd);
+      debug('Removed Startup folder .cmd entry');
     }
   } catch { /* ignore */ }
 
-  // Also try removing schtasks entry (may not exist)
+  // Remove .cmd launcher script from ~/.nightytidy/
   try {
-    execSync(`schtasks /delete /tn "${SERVICE_NAME}" /f`, { stdio: 'pipe' });
+    if (fs.existsSync(AGENT_CMD)) {
+      fs.unlinkSync(AGENT_CMD);
+      debug('Removed launcher script');
+    }
+  } catch { /* ignore */ }
+
+  // Remove Task Scheduler entry (try both PowerShell and schtasks)
+  try {
+    execSync(
+      `powershell.exe -NoProfile -Command "Unregister-ScheduledTask -TaskName '${SERVICE_NAME}' -Confirm:\\$false"`,
+      { stdio: 'pipe', timeout: 15000 },
+    );
     debug('Removed Task Scheduler entry');
-  } catch { /* ignore — may not have been registered via schtasks */ }
+  } catch {
+    try {
+      execSync(`schtasks /delete /tn "${SERVICE_NAME}" /f`, { stdio: 'pipe' });
+      debug('Removed Task Scheduler entry (schtasks)');
+    } catch { /* ignore — may not have been registered */ }
+  }
 }
 
 function _registerMacOS(cmd) {