claude-code-session-manager 0.6.0 → 0.7.1

package/src/main/scheduler.cjs

@@ -220,23 +220,22 @@ function reconcile(state) {
 
 // ---------- next-reset detection ----------
 
-let cachedNextReset = { at: null, fetchedAt: 0 };
+let cachedNextReset = null;
 let cachedUtilization = null; // five_hour utilization %, 0–100, or null if unknown
 
 async function refreshNextReset() {
   try {
     const r = await billing.fetchUsage();
-    const at = r?.usage?.five_hour?.resets_at ?? null;
-    cachedNextReset = { at, fetchedAt: Date.now() };
+    cachedNextReset = r?.usage?.five_hour?.resets_at ?? null;
     cachedUtilization = r?.usage?.five_hour?.utilization ?? cachedUtilization;
-    return at;
+    return cachedNextReset;
   } catch {
-    return cachedNextReset.at;
+    return cachedNextReset;
   }
 }
 
 function getNextResetCached() {
-  return cachedNextReset.at;
+  return cachedNextReset;
 }
 
 // ---------- timer ----------
@@ -245,6 +244,8 @@ let mainWindow = null;
 let fireTimer = null;
 let resumeTimer = null;
 let pollTimer = null;
+let rescheduleInterval = null;
+let initialPollTimeout = null;
 let isExecuting = false;
 let cancelToken = { cancelled: false };
 let claudeBinPathCached = null;
@@ -315,7 +316,6 @@ async function rescheduleTimer() {
 function setPaused(reason, resumeAtIso) {
   const s = readQueue();
   if (s.paused && s.paused.reason === reason) {
-    // already paused for this reason; just refresh resumeAt if newer
     if (resumeAtIso) s.paused.resumeAt = resumeAtIso;
   } else {
     s.paused = { reason, since: new Date().toISOString(), resumeAt: resumeAtIso || null };
@@ -324,19 +324,18 @@ function setPaused(reason, resumeAtIso) {
   broadcast();
   cancelToken.cancelled = true;
   if (resumeTimer) { clearTimeout(resumeTimer); resumeTimer = null; }
-  if (resumeAtIso) {
-    // Resume 30s after the reset to give the auth/billing endpoint time to flip.
-    const delay = Math.max(30_000, new Date(resumeAtIso).getTime() - Date.now() + 30_000);
-    if (delay <= 0x7fffffff) {
-      resumeTimer = setTimeout(() => {
-        clearPause('resume-timer');
-        runDueJobs().catch(() => {});
-      }, delay);
-      console.log(`[scheduler] paused (${reason}); auto-resume in ${Math.round(delay/1000)}s`);
-    } else {
-      console.warn(`[scheduler] paused (${reason}); resumeAt too far in future for setTimeout (${delay}ms)`);
-    }
+  if (!resumeAtIso) return;
+  // Resume 30s after the reset to give the auth/billing endpoint time to flip.
+  const delay = Math.max(30_000, new Date(resumeAtIso).getTime() - Date.now() + 30_000);
+  if (delay > 0x7fffffff) {
+    console.warn(`[scheduler] paused (${reason}); resumeAt too far for setTimeout (${delay}ms)`);
+    return;
   }
+  resumeTimer = setTimeout(() => {
+    clearPause('resume-timer');
+    runDueJobs().catch(() => {});
+  }, delay);
+  console.log(`[scheduler] paused (${reason}); auto-resume in ${Math.round(delay/1000)}s`);
 }
 
 function clearPause(source) {
@@ -350,6 +349,16 @@ function clearPause(source) {
   }
 }
 
+/** Mutate a job in place to "pending" with cleared run metadata. */
+function resetJobFields(job, errorMsg) {
+  job.status = 'pending';
+  job.runId = null;
+  job.startedAt = null;
+  job.finishedAt = null;
+  job.exitCode = null;
+  job.error = errorMsg ?? null;
+}
+
 /** Scan the tail of a job's log for the canonical rate-limit signal. We look
  *  at the last 16 KB — final result event always lands at the end. */
 function detectRateLimitInLog(logPath) {
@@ -514,12 +523,7 @@ async function runDueJobs() {
           if (i2 >= 0) {
             const treatAsPending = res.rateLimited || (sn.paused && sn.paused.reason === 'rate_limit');
             if (treatAsPending) {
-              sn.jobs[i2].status = 'pending';
-              sn.jobs[i2].runId = null;
-              sn.jobs[i2].startedAt = null;
-              sn.jobs[i2].finishedAt = null;
-              sn.jobs[i2].exitCode = null;
-              sn.jobs[i2].error = res.rateLimited ? 'paused: rate limit' : 'paused: queue halted';
+              resetJobFields(sn.jobs[i2], res.rateLimited ? 'paused: rate limit' : 'paused: queue halted');
             } else {
               sn.jobs[i2].status = res.exitCode === 0 ? 'completed' : 'failed';
               sn.jobs[i2].finishedAt = new Date().toISOString();
@@ -632,12 +636,7 @@ function registerScheduleHandlers() {
     const state = readQueue();
     const idx = state.jobs.findIndex((j) => j.slug === slug);
     if (idx < 0) return { ok: false, error: 'not found' };
-    state.jobs[idx].status = 'pending';
-    state.jobs[idx].runId = null;
-    state.jobs[idx].startedAt = null;
-    state.jobs[idx].finishedAt = null;
-    state.jobs[idx].exitCode = null;
-    state.jobs[idx].error = null;
+    resetJobFields(state.jobs[idx]);
     writeQueue(state);
     broadcast();
     return { ok: true };
@@ -704,14 +703,16 @@ async function init() {
 
   await rescheduleTimer();
   // Refresh next-reset every 10 minutes — billing window can shift if usage
-  // resets early or the auth token rotates.
-  setInterval(() => { rescheduleTimer().catch(() => {}); }, 10 * 60_000);
+  // resets early or the auth token rotates. Tracked so re-init doesn't leak.
+  if (rescheduleInterval) clearInterval(rescheduleInterval);
+  rescheduleInterval = setInterval(() => { rescheduleTimer().catch(() => {}); }, 10 * 60_000);
   // when-available poll loop. Tick every 2 minutes; the function itself is
   // a no-op when policy != 'when-available' or queue is empty/paused.
   if (pollTimer) clearInterval(pollTimer);
   pollTimer = setInterval(() => { pollWhenAvailable().catch(() => {}); }, 2 * 60_000);
   // First tick fires after a short delay so billing is warmed up.
-  setTimeout(() => { pollWhenAvailable().catch(() => {}); }, 15_000);
+  if (initialPollTimeout) clearTimeout(initialPollTimeout);
+  initialPollTimeout = setTimeout(() => { pollWhenAvailable().catch(() => {}); }, 15_000);
 }
 
 module.exports = { registerScheduleHandlers, attachWindow, init, ROOT, PRDS_DIR };

package/src/main/voiceSettings.cjs

@@ -260,7 +260,6 @@ async function saveWizard(state) {
 const DEFAULT_TURN_DETECTOR = Object.freeze({
   enabled: false,
   mode: 'off',           // 'audio' | 'text' | 'off'
-  dictationMode: false,
   schemaVersion: TURN_DETECTOR_SCHEMA,
 });
 
@@ -270,21 +269,13 @@ function isValidTurnDetectorState(t) {
   if (!t || typeof t !== 'object') return false;
   if (typeof t.enabled !== 'boolean') return false;
   if (typeof t.mode !== 'string' || !TURN_DETECTOR_MODES.has(t.mode)) return false;
-  if (typeof t.dictationMode !== 'boolean') return false;
   return true;
 }
 
 function normalizeTurnDetector(t) {
   const mode = TURN_DETECTOR_MODES.has(t.mode) ? t.mode : 'off';
-  // Cross-field invariant: `enabled` and `mode === 'off'` are inconsistent.
-  // We normalize so callers can be sloppy: if mode is 'off' then enabled=false.
   const enabled = mode === 'off' ? false : !!t.enabled;
-  return {
-    enabled,
-    mode,
-    dictationMode: !!t.dictationMode,
-    schemaVersion: TURN_DETECTOR_SCHEMA,
-  };
+  return { enabled, mode, schemaVersion: TURN_DETECTOR_SCHEMA };
 }
 
 /**

package/src/preload/api.d.ts

@@ -169,8 +169,6 @@ export interface VoiceTurnDetectorState {
   enabled: boolean;
   /** 'audio' = smart-turn-v3 (planned); 'text' = rejected on license; 'off' = pure-VAD (default). */
   mode: 'audio' | 'text' | 'off';
-  /** When true, bypass the model and use pure-VAD endpointing (out-of-distribution code). */
-  dictationMode: boolean;
   schemaVersion: 1;
 }