paneful 0.9.17 → 0.9.19

package/README.md

@@ -67,6 +67,34 @@ Press `Cmd+P` to open the command palette. Quickly switch projects, launch favou
 
 The sidebar shows the current Git branch next to each project's working directory as a small pill badge. Updates automatically every 10 seconds. Non-git directories show no badge.
 
+### Scheduled Jobs (beta)
+
+Run any shell command on a recurring schedule. Open the **Schedules** section in the sidebar (below Favourites) and click **+** to create one. Pick a name, a working directory via the Finder picker, the command to run, and a schedule — every N minutes/hours/days, daily at HH:MM, weekly on chosen days, or a raw cron expression. The next-fire time is shown live as you build the schedule.
+
+Each fire spawns a fresh server-side terminal in your `$SHELL` (login + interactive, so your full PATH is loaded) and runs the command — schedules are completely separate from projects so they don't pollute your layouts. The command runs, then drops into an interactive shell, so the terminal **never dies on its own** — you decide when to close it.
+
+Every run is captured to disk so the history is inspectable later. Click any past run from the schedule's history dialog to open an interactive viewer:
+
+- **Active runs** — live streaming output, full keystroke forwarding (answer Claude prompts, type follow-up commands, etc.).
+- **Closed runs** — read-only replay of the captured log via xterm so colors and formatting are preserved.
+- **Pause / Resume** — SIGSTOP / SIGCONT the running process. The shell freezes exactly where it was and continues from that exact state when you come back.
+- **Terminate** — kills the run when you're done with it.
+
+A common pattern: schedule a Claude CLI command (`claude --dangerously-skip-permissions "..."`) to run at 8am on weekdays. When it fires you get a toast; click it to drop into the live terminal, answer any prompts, and let it work.
+
+### Source Control
+
+Press `Cmd+Shift+G` (or click the branch icon in the toolbar) to open the source control panel — a resizable right-side panel that shows the active project's working changes. Powered by `git status` + `fs.watch`, so updates are instant. Includes:
+
+- **Branch bar** with current branch, ahead/behind counts, and one-click pull (`--ff-only`) and push.
+- **File list** grouped by Staged Changes, Changes, Untracked, and Conflicted. Each row has hover actions for stage, unstage, discard, and "Open in editor" (uses your system's default app association).
+- **Multi-select** with Cmd-click (toggle) and Shift-click (range) for bulk stage/unstage/discard within a group.
+- **Diff view** — click any file to see the full file with line numbers, red/green backgrounds for added/removed lines, and syntax highlighting for ~25 languages (TypeScript, Python, Go, Rust, Swift, Java, C/C++, and more).
+- **Inline commit** message + button; auto-clears on success.
+- **Stash** — create (with optional message, includes untracked), apply, pop, or drop directly from the panel.
+
+The panel only polls its data when open, and the file watcher only runs while focused on the active project — zero overhead when collapsed.
+
 ### AI Agent Detection
 
 Automatically detects when Claude Code or Codex CLI is running in a Paneful terminal. A purple **AI** badge appears next to the project name in the sidebar — pulsing when the agent is actively working, dimmed when idle. Disappears instantly when the agent exits. Uses zero filesystem access; detection is purely in-memory via the PTY process name and terminal output timestamps.
@@ -131,6 +159,7 @@ Paneful checks for newer versions on npm and shows a notification in the sidebar
 | `Ctrl+Shift+Arrow` | Move focus to adjacent pane     |
 | `Shift+Arrow`      | Swap focused pane with adjacent |
 | `Cmd+D`            | Toggle sidebar                  |
+| `Cmd+Shift+G`      | Toggle source control panel     |
 | `Cmd+T`            | Cycle through layout presets    |
 | `Cmd+R`            | Auto reorganize panes           |
 

package/dist/server/git-source-control.js

@@ -0,0 +1,398 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { watch } from 'node:fs';
+const execFileP = promisify(execFile);
+const SAFETY_POLL_MS = 15_000;
+const WATCH_DEBOUNCE_MS = 300;
+// Headroom for whole-file diffs (git -U99999). Most source files fit comfortably.
+const DIFF_MAX_BYTES = 5_000_000;
+const DIFF_TIMEOUT_MS = 5_000;
+const ACTION_TIMEOUT_MS = 10_000;
+const NETWORK_TIMEOUT_MS = 120_000;
+// Force enough unified-diff context to cover any reasonable file
+const FULL_CONTEXT_FLAG = '-U99999';
+// Filenames/dirs in change events to ignore (lots of churn, no user-visible status impact)
+const IGNORE_PATHS = ['.git/objects', '.git/lfs', '.git/logs', 'node_modules', '.next/cache'];
+export class GitSourceControl {
+    projectStore;
+    onStatus;
+    activeProjectId = null;
+    lastStatus = null;
+    safetyTimer = null;
+    debounceTimer = null;
+    watcher = null;
+    polling = false;
+    destroyed = false;
+    paused = true;
+    constructor(projectStore, onStatus) {
+        this.projectStore = projectStore;
+        this.onStatus = onStatus;
+    }
+    setActive(projectId) {
+        if (projectId === this.activeProjectId)
+            return;
+        this.stopWatcher();
+        this.activeProjectId = projectId;
+        this.lastStatus = null;
+        if (projectId && !this.paused) {
+            this.startWatcher(projectId);
+            this.poll();
+        }
+    }
+    resume() {
+        if (this.destroyed || !this.paused)
+            return;
+        this.paused = false;
+        if (this.activeProjectId) {
+            this.startWatcher(this.activeProjectId);
+            this.poll();
+            this.safetyTimer = setInterval(() => this.poll(), SAFETY_POLL_MS);
+        }
+    }
+    pause() {
+        this.paused = true;
+        this.stopWatcher();
+        if (this.safetyTimer) {
+            clearInterval(this.safetyTimer);
+            this.safetyTimer = null;
+        }
+        if (this.debounceTimer) {
+            clearTimeout(this.debounceTimer);
+            this.debounceTimer = null;
+        }
+    }
+    destroy() {
+        this.destroyed = true;
+        this.pause();
+        this.lastStatus = null;
+        this.activeProjectId = null;
+    }
+    startWatcher(projectId) {
+        const project = this.projectStore.list().find((p) => p.id === projectId);
+        if (!project)
+            return;
+        try {
+            this.watcher = watch(project.cwd, { recursive: true }, (_event, filename) => {
+                if (!filename)
+                    return;
+                // Skip noisy paths (e.g., git objects, node_modules build chatter)
+                for (const ignore of IGNORE_PATHS) {
+                    if (filename.includes(ignore))
+                        return;
+                }
+                this.scheduleRePoll();
+            });
+            this.watcher.on('error', () => {
+                // Watcher failed (path missing, permission denied, etc.) — safety poll still runs
+                this.stopWatcher();
+            });
+        }
+        catch {
+            // fs.watch unavailable or path bad — silently rely on safety poll
+        }
+    }
+    stopWatcher() {
+        if (this.watcher) {
+            try {
+                this.watcher.close();
+            }
+            catch { }
+            this.watcher = null;
+        }
+    }
+    scheduleRePoll() {
+        if (this.debounceTimer)
+            clearTimeout(this.debounceTimer);
+        this.debounceTimer = setTimeout(() => {
+            this.debounceTimer = null;
+            this.poll();
+        }, WATCH_DEBOUNCE_MS);
+    }
+    async requestDiff(projectId, file, kind) {
+        const project = this.projectStore.list().find((p) => p.id === projectId);
+        if (!project)
+            return null;
+        return this.getDiff(project.cwd, file, kind);
+    }
+    async stage(projectId, files) {
+        return this.runAction(projectId, ['add', '--', ...files]);
+    }
+    async unstage(projectId, files) {
+        return this.runAction(projectId, ['restore', '--staged', '--', ...files]);
+    }
+    async discard(projectId, trackedFiles, untrackedFiles) {
+        const project = this.projectStore.list().find((p) => p.id === projectId);
+        if (!project)
+            return { ok: false, error: 'project not found' };
+        try {
+            if (trackedFiles.length > 0) {
+                await execFileP('git', ['restore', '--staged', '--worktree', '--', ...trackedFiles], {
+                    cwd: project.cwd,
+                    timeout: ACTION_TIMEOUT_MS,
+                });
+            }
+            if (untrackedFiles.length > 0) {
+                await execFileP('git', ['clean', '-f', '--', ...untrackedFiles], {
+                    cwd: project.cwd,
+                    timeout: ACTION_TIMEOUT_MS,
+                });
+            }
+            this.poll();
+            return { ok: true };
+        }
+        catch (e) {
+            return { ok: false, error: e.message };
+        }
+    }
+    async commit(projectId, message) {
+        if (!message.trim())
+            return { ok: false, error: 'commit message is empty' };
+        return this.runAction(projectId, ['commit', '-m', message]);
+    }
+    async push(projectId) {
+        return this.runNetworkAction(projectId, ['push']);
+    }
+    async pull(projectId) {
+        return this.runNetworkAction(projectId, ['pull', '--ff-only']);
+    }
+    async stashCreate(projectId, message) {
+        const args = message.trim() ? ['stash', 'push', '-u', '-m', message] : ['stash', 'push', '-u'];
+        return this.runAction(projectId, args);
+    }
+    async stashPop(projectId, index) {
+        return this.runAction(projectId, ['stash', 'pop', `stash@{${index}}`]);
+    }
+    async stashApply(projectId, index) {
+        return this.runAction(projectId, ['stash', 'apply', `stash@{${index}}`]);
+    }
+    async stashDrop(projectId, index) {
+        return this.runAction(projectId, ['stash', 'drop', `stash@{${index}}`]);
+    }
+    async runNetworkAction(projectId, args) {
+        const project = this.projectStore.list().find((p) => p.id === projectId);
+        if (!project)
+            return { ok: false, error: 'project not found' };
+        try {
+            await execFileP('git', args, {
+                cwd: project.cwd,
+                timeout: NETWORK_TIMEOUT_MS,
+                env: { ...process.env, GIT_TERMINAL_PROMPT: '0' },
+            });
+            this.poll();
+            return { ok: true };
+        }
+        catch (e) {
+            const err = e;
+            const msg = (err.stderr || err.message || 'unknown error').trim();
+            return { ok: false, error: msg };
+        }
+    }
+    async runAction(projectId, args) {
+        const project = this.projectStore.list().find((p) => p.id === projectId);
+        if (!project)
+            return { ok: false, error: 'project not found' };
+        try {
+            await execFileP('git', args, { cwd: project.cwd, timeout: ACTION_TIMEOUT_MS });
+            this.poll();
+            return { ok: true };
+        }
+        catch (e) {
+            return { ok: false, error: e.message };
+        }
+    }
+    async poll() {
+        if (this.destroyed || this.polling)
+            return;
+        const projectId = this.activeProjectId;
+        if (!projectId)
+            return;
+        this.polling = true;
+        try {
+            const project = this.projectStore.list().find((p) => p.id === projectId);
+            if (!project) {
+                if (this.lastStatus !== null) {
+                    this.lastStatus = null;
+                    this.onStatus(projectId, null);
+                }
+                return;
+            }
+            const status = await this.getStatus(project.cwd);
+            if (this.destroyed || this.activeProjectId !== projectId)
+                return;
+            if (this.statusEqual(status, this.lastStatus))
+                return;
+            this.lastStatus = status;
+            this.onStatus(projectId, status);
+        }
+        catch {
+            // Swallow — leave previous state in place
+        }
+        finally {
+            this.polling = false;
+        }
+    }
+    async getStatus(cwd) {
+        try {
+            const [statusRes, stashRes] = await Promise.all([
+                execFileP('git', ['status', '--porcelain=v2', '--untracked-files=all'], {
+                    cwd,
+                    timeout: 3000,
+                    maxBuffer: 4 * 1024 * 1024,
+                }),
+                execFileP('git', ['stash', 'list'], { cwd, timeout: 2000, maxBuffer: 256 * 1024 }).catch(() => ({ stdout: '' })),
+            ]);
+            const status = this.parseStatus(statusRes.stdout);
+            status.stashes = this.parseStashes(stashRes.stdout);
+            return status;
+        }
+        catch {
+            return null;
+        }
+    }
+    parseStashes(stdout) {
+        const out = [];
+        for (const line of stdout.split('\n')) {
+            if (!line)
+                continue;
+            // "stash@{0}: WIP on master: abc1234 commit subject" OR "stash@{0}: On master: my message"
+            const m = line.match(/^stash@\{(\d+)\}: (?:WIP )?[oO]n (\S+?): (?:[0-9a-f]+ )?(.+)$/);
+            if (!m)
+                continue;
+            out.push({ index: parseInt(m[1], 10), branch: m[2], message: m[3] });
+        }
+        return out;
+    }
+    parseStatus(stdout) {
+        const staged = [];
+        const changes = [];
+        const untracked = [];
+        const conflicted = [];
+        for (const line of stdout.split('\n')) {
+            if (line.length === 0)
+                continue;
+            if (line.startsWith('# '))
+                continue;
+            if (line.startsWith('? ')) {
+                untracked.push({ path: line.slice(2), status: '?' });
+                continue;
+            }
+            if (line.startsWith('! '))
+                continue;
+            if (line.startsWith('1 ')) {
+                // 1 XY sub mH mI mW hH hI <path>
+                const m = line.match(/^1 (\S\S) \S+ \S+ \S+ \S+ \S+ \S+ (.+)$/);
+                if (!m)
+                    continue;
+                const xy = m[1];
+                const path = m[2];
+                const x = xy[0];
+                const y = xy[1];
+                if (x !== '.' && x !== ' ') {
+                    staged.push({ path, status: x });
+                }
+                if (y !== '.' && y !== ' ') {
+                    changes.push({ path, status: y });
+                }
+                continue;
+            }
+            if (line.startsWith('2 ')) {
+                // 2 XY sub mH mI mW hH hI Xscore <path>\t<origPath>
+                const m = line.match(/^2 (\S\S) \S+ \S+ \S+ \S+ \S+ \S+ \S+ (.+)$/);
+                if (!m)
+                    continue;
+                const xy = m[1];
+                const rest = m[2];
+                const tabIdx = rest.indexOf('\t');
+                const path = tabIdx >= 0 ? rest.slice(0, tabIdx) : rest;
+                const oldPath = tabIdx >= 0 ? rest.slice(tabIdx + 1) : undefined;
+                const x = xy[0];
+                const y = xy[1];
+                if (x !== '.' && x !== ' ') {
+                    staged.push({ path, oldPath, status: x });
+                }
+                if (y !== '.' && y !== ' ') {
+                    changes.push({ path, oldPath, status: y });
+                }
+                continue;
+            }
+            if (line.startsWith('u ')) {
+                // u XY sub m1 m2 m3 mW h1 h2 h3 <path>
+                const m = line.match(/^u \S\S \S+ \S+ \S+ \S+ \S+ \S+ \S+ \S+ (.+)$/);
+                if (!m)
+                    continue;
+                conflicted.push({ path: m[1], status: 'U' });
+                continue;
+            }
+        }
+        return { staged, changes, untracked, conflicted, stashes: [] };
+    }
+    async getDiff(cwd, file, kind) {
+        let args;
+        if (kind === 'staged') {
+            args = ['diff', FULL_CONTEXT_FLAG, '--cached', '--', file];
+        }
+        else if (kind === 'untracked') {
+            // Show the file's full contents as an all-additions diff
+            args = ['diff', FULL_CONTEXT_FLAG, '--no-index', '--', '/dev/null', file];
+        }
+        else {
+            args = ['diff', FULL_CONTEXT_FLAG, '--', file];
+        }
+        try {
+            const { stdout } = await execFileP('git', args, {
+                cwd,
+                timeout: DIFF_TIMEOUT_MS,
+                maxBuffer: DIFF_MAX_BYTES + 1024,
+            });
+            const truncated = stdout.length >= DIFF_MAX_BYTES;
+            const diff = truncated ? stdout.slice(0, DIFF_MAX_BYTES) : stdout;
+            const binary = /^Binary files .* differ$/m.test(diff);
+            return { diff, binary, truncated };
+        }
+        catch (e) {
+            // `git diff --no-index` exits 1 when files differ — still valid output
+            const err = e;
+            if (err.stdout !== undefined && (err.code === 1 || kind === 'untracked')) {
+                const truncated = err.stdout.length >= DIFF_MAX_BYTES;
+                const diff = truncated ? err.stdout.slice(0, DIFF_MAX_BYTES) : err.stdout;
+                const binary = /^Binary files .* differ$/m.test(diff);
+                return { diff, binary, truncated };
+            }
+            return { diff: '', binary: false, truncated: false };
+        }
+    }
+    statusEqual(a, b) {
+        if (a === b)
+            return true;
+        if (!a || !b)
+            return false;
+        return (this.entriesEqual(a.staged, b.staged) &&
+            this.entriesEqual(a.changes, b.changes) &&
+            this.entriesEqual(a.untracked, b.untracked) &&
+            this.entriesEqual(a.conflicted, b.conflicted) &&
+            this.stashesEqual(a.stashes, b.stashes));
+    }
+    stashesEqual(a, b) {
+        if (a.length !== b.length)
+            return false;
+        for (let i = 0; i < a.length; i++) {
+            if (a[i].index !== b[i].index || a[i].message !== b[i].message || a[i].branch !== b[i].branch) {
+                return false;
+            }
+        }
+        return true;
+    }
+    entriesEqual(a, b) {
+        if (a.length !== b.length)
+            return false;
+        for (let i = 0; i < a.length; i++) {
+            if (a[i].path !== b[i].path)
+                return false;
+            if (a[i].status !== b[i].status)
+                return false;
+            if (a[i].oldPath !== b[i].oldPath)
+                return false;
+        }
+        return true;
+    }
+}

package/dist/server/index.js

@@ -268,6 +268,37 @@ async function startServer(devMode, port) {
             res.json({ valid: false });
         }
     });
+    // macOS-only Finder folder picker via osascript. Returns the chosen POSIX path or null.
+    app.post('/api/pick-folder', async (req, res) => {
+        if (process.platform !== 'darwin') {
+            res.json({ path: null, error: 'folder picker is macOS-only' });
+            return;
+        }
+        const { default: defaultLocation } = req.body ?? {};
+        const seed = (typeof defaultLocation === 'string' && defaultLocation)
+            ? defaultLocation.replace(/^~/, os.homedir())
+            : os.homedir();
+        const { execFile } = await import('node:child_process');
+        const script = `
+      try
+        tell application "System Events"
+          activate
+          set chosen to choose folder with prompt "Select a folder" default location POSIX file "${seed.replace(/"/g, '\\"')}"
+        end tell
+        return POSIX path of chosen
+      on error number -128
+        return ""
+      end try
+    `;
+        execFile('osascript', ['-e', script], { timeout: 120_000 }, (err, stdout) => {
+            if (err) {
+                res.json({ path: null });
+                return;
+            }
+            const trimmed = stdout.trim().replace(/\/$/, '');
+            res.json({ path: trimmed || null });
+        });
+    });
     // Resolve a dropped file's full path via tiered search (stat → find → Spotlight)
     const resolvePathCache = new Map();
     const RESOLVE_CACHE_TTL = 30_000;

package/dist/server/pty-manager.js

@@ -3,7 +3,7 @@ import { execSync } from 'node:child_process';
 import os from 'node:os';
 export class PtyManager {
     sessions = new Map();
-    spawn(terminalId, projectId, cwd, onOutput, onExit) {
+    spawn(terminalId, projectId, cwd, onOutput, onExit, command) {
         const shell = process.env.SHELL || (os.platform() === 'win32' ? 'powershell.exe' : '/bin/bash');
         // Filter out undefined values from process.env before spreading
         const env = {};
@@ -14,7 +14,22 @@ export class PtyManager {
         env.TERM = 'xterm-256color';
         env.LANG = 'en_US.UTF-8';
         env.LC_ALL = 'en_US.UTF-8';
-        const proc = pty.spawn(shell, ['--login'], {
+        // Command mode: run the command in the user's own login+interactive shell,
+        // then drop back into an interactive shell so the PTY stays alive (matches
+        // Terminal.app behavior). We use `-l -i` so both profile AND rc files
+        // (e.g. ~/.zshrc) are sourced — that's where user-installed binaries
+        // like `claude`, `nvm`-managed `node`, etc. land on PATH.
+        //
+        // Passing the command via $0 + eval keeps the user's command opaque to the
+        // wrapper script's quoting.
+        const wrapper = `eval "$0"; printf '\\r\\n\\033[90m[paneful: command finished — type exit to close this run]\\033[0m\\r\\n'; exec "$1" -i -l`;
+        const isCommandMode = !!command;
+        // bash and zsh both accept -l -i -c SCRIPT ARG ARG. Fish doesn't, so fall back to bash.
+        const wrapperShell = /\/(bash|zsh)$/.test(shell) ? shell : '/bin/bash';
+        const args = isCommandMode
+            ? ['-l', '-i', '-c', wrapper, command, shell]
+            : ['--login'];
+        const proc = pty.spawn(isCommandMode ? wrapperShell : shell, args, {
             name: 'xterm-256color',
             cols: 80,
             rows: 24,
@@ -70,6 +85,26 @@ export class PtyManager {
         }
         this.sessions.clear();
     }
+    /**
+     * Pauses the PTY by sending SIGSTOP to its process group. The shell and its
+     * descendants freeze in place — no CPU, no I/O — and their in-memory state
+     * is preserved until `cont()` is called.
+     */
+    pause(terminalId) {
+        const managed = this.sessions.get(terminalId);
+        if (!managed)
+            return false;
+        return signalPty(managed.process.pid, 'SIGSTOP');
+    }
+    /**
+     * Continues a paused PTY (SIGCONT). The process picks up exactly where it was.
+     */
+    cont(terminalId) {
+        const managed = this.sessions.get(terminalId);
+        if (!managed)
+            return false;
+        return signalPty(managed.process.pid, 'SIGCONT');
+    }
     terminalExists(terminalId) {
         return this.sessions.has(terminalId);
     }
@@ -130,3 +165,20 @@ export class PtyManager {
 const RUNTIME_PROCESSES = new Set(['node', 'python', 'python3']);
 // Match agent binary names at the end of a path or as a standalone token
 const AGENT_CMD_PATTERN = /(?:^|\/)(codex|claude|aider)(?:\s|$)/;
+// Signal the PTY's whole process group (negative pid) so children pause/continue with it.
+// Falls back to single-process if the group signal fails (unlikely on macOS).
+function signalPty(pid, signal) {
+    try {
+        process.kill(-pid, signal);
+        return true;
+    }
+    catch {
+        try {
+            process.kill(pid, signal);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+}

package/dist/server/schedule-store.js

@@ -0,0 +1,99 @@
+import fs from 'node:fs';
+import path from 'node:path';
+const RUN_HISTORY_LIMIT = 200;
+export class ScheduleStore {
+    jobs = new Map();
+    runs = [];
+    filePath;
+    constructor(dataDir, getProjectCwd) {
+        this.filePath = path.join(dataDir, 'schedules.json');
+        if (fs.existsSync(this.filePath)) {
+            try {
+                const raw = JSON.parse(fs.readFileSync(this.filePath, 'utf-8'));
+                let mutated = false;
+                for (const job of raw.jobs ?? []) {
+                    // Migration: older schedules used projectId, now we store cwd directly
+                    if (!job.cwd && job.projectId && getProjectCwd) {
+                        const cwd = getProjectCwd(job.projectId);
+                        if (cwd) {
+                            job.cwd = cwd;
+                            mutated = true;
+                        }
+                    }
+                    delete job.projectId;
+                    if (job.cwd)
+                        this.jobs.set(job.id, job);
+                }
+                this.runs = (raw.runs ?? []).slice(-RUN_HISTORY_LIMIT);
+                if (mutated)
+                    this.persist();
+            }
+            catch {
+                // corrupt file, start fresh
+            }
+        }
+    }
+    listJobs() {
+        return Array.from(this.jobs.values()).sort((a, b) => a.createdAt - b.createdAt);
+    }
+    getJob(id) {
+        return this.jobs.get(id);
+    }
+    createJob(job) {
+        this.jobs.set(job.id, job);
+        this.persist();
+    }
+    updateJob(job) {
+        if (!this.jobs.has(job.id))
+            return;
+        this.jobs.set(job.id, job);
+        this.persist();
+    }
+    deleteJob(id) {
+        this.jobs.delete(id);
+        // Drop runs for the deleted job too
+        this.runs = this.runs.filter((r) => r.jobId !== id);
+        this.persist();
+    }
+    listRuns(jobId) {
+        return jobId ? this.runs.filter((r) => r.jobId === jobId) : this.runs.slice();
+    }
+    addRun(run) {
+        this.runs.push(run);
+        if (this.runs.length > RUN_HISTORY_LIMIT) {
+            this.runs.splice(0, this.runs.length - RUN_HISTORY_LIMIT);
+        }
+        this.persist();
+    }
+    updateRun(runId, patch) {
+        const idx = this.runs.findIndex((r) => r.id === runId);
+        if (idx < 0)
+            return undefined;
+        this.runs[idx] = { ...this.runs[idx], ...patch };
+        this.persist();
+        return this.runs[idx];
+    }
+    removeRun(runId) {
+        this.runs = this.runs.filter((r) => r.id !== runId);
+        this.persist();
+    }
+    hasEnabledJobs() {
+        for (const job of this.jobs.values()) {
+            if (job.enabled)
+                return true;
+        }
+        return false;
+    }
+    persist() {
+        try {
+            const dir = path.dirname(this.filePath);
+            if (!fs.existsSync(dir))
+                fs.mkdirSync(dir, { recursive: true });
+            const data = { jobs: this.listJobs(), runs: this.runs };
+            fs.writeFileSync(this.filePath, JSON.stringify(data, null, 2));
+        }
+        catch {
+            console.error('Failed to persist schedules');
+        }
+    }
+}