paneful 0.9.18 → 0.9.20

package/README.md

@@ -67,6 +67,21 @@ 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:

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');
+        }
+    }
+}

package/dist/server/scheduler.js

@@ -0,0 +1,189 @@
+/**
+ * Minimal cron matcher. Supports 5-field standard cron:
+ *   minute hour day-of-month month day-of-week
+ *
+ * Field syntax:
+ *   * (any)
+ *   N (literal)
+ *   N,M,O (list)
+ *   N-M (range)
+ *   *\/N (step)
+ *   N-M/K (stepped range)
+ *
+ * Day-of-week: 0-6 (0=Sunday).
+ */
+const RANGES = [
+    [0, 59], // minute
+    [0, 23], // hour
+    [1, 31], // day of month
+    [1, 12], // month
+    [0, 6], // day of week
+];
+function parseField(field, min, max) {
+    if (field === '*')
+        return 'any';
+    const values = new Set();
+    for (const part of field.split(',')) {
+        let stepStr;
+        let rangeStr = part;
+        const slashIdx = part.indexOf('/');
+        if (slashIdx >= 0) {
+            rangeStr = part.slice(0, slashIdx);
+            stepStr = part.slice(slashIdx + 1);
+        }
+        const step = stepStr ? parseInt(stepStr, 10) : 1;
+        if (!Number.isFinite(step) || step <= 0)
+            continue;
+        let lo;
+        let hi;
+        if (rangeStr === '*') {
+            lo = min;
+            hi = max;
+        }
+        else if (rangeStr.includes('-')) {
+            const [a, b] = rangeStr.split('-');
+            lo = parseInt(a, 10);
+            hi = parseInt(b, 10);
+        }
+        else {
+            lo = parseInt(rangeStr, 10);
+            hi = lo;
+        }
+        if (!Number.isFinite(lo) || !Number.isFinite(hi))
+            continue;
+        for (let v = lo; v <= hi; v += step) {
+            if (v >= min && v <= max)
+                values.add(v);
+        }
+    }
+    return values;
+}
+export function parseCron(expr) {
+    // Aliases
+    let trimmed = expr.trim();
+    switch (trimmed) {
+        case '@yearly':
+        case '@annually':
+            trimmed = '0 0 1 1 *';
+            break;
+        case '@monthly':
+            trimmed = '0 0 1 * *';
+            break;
+        case '@weekly':
+            trimmed = '0 0 * * 0';
+            break;
+        case '@daily':
+        case '@midnight':
+            trimmed = '0 0 * * *';
+            break;
+        case '@hourly':
+            trimmed = '0 * * * *';
+            break;
+    }
+    const fields = trimmed.split(/\s+/);
+    if (fields.length !== 5)
+        return null;
+    const parsed = {
+        minute: parseField(fields[0], RANGES[0][0], RANGES[0][1]),
+        hour: parseField(fields[1], RANGES[1][0], RANGES[1][1]),
+        dom: parseField(fields[2], RANGES[2][0], RANGES[2][1]),
+        month: parseField(fields[3], RANGES[3][0], RANGES[3][1]),
+        dow: parseField(fields[4], RANGES[4][0], RANGES[4][1]),
+    };
+    return parsed;
+}
+function matches(set, val) {
+    return set === 'any' || set.has(val);
+}
+export function cronMatches(expr, date) {
+    const parsed = parseCron(expr);
+    if (!parsed)
+        return false;
+    return (matches(parsed.minute, date.getMinutes()) &&
+        matches(parsed.hour, date.getHours()) &&
+        matches(parsed.dom, date.getDate()) &&
+        matches(parsed.month, date.getMonth() + 1) &&
+        matches(parsed.dow, date.getDay()));
+}
+/**
+ * Compute the next firing time at-or-after `from`, scanning up to
+ * `maxMinutes` ahead. Used for "next run in X" UI hints.
+ */
+export function nextRun(expr, from, maxMinutes = 60 * 24 * 7) {
+    const parsed = parseCron(expr);
+    if (!parsed)
+        return null;
+    const cursor = new Date(from);
+    cursor.setSeconds(0, 0);
+    cursor.setMinutes(cursor.getMinutes() + 1);
+    for (let i = 0; i < maxMinutes; i++) {
+        if (matches(parsed.minute, cursor.getMinutes()) &&
+            matches(parsed.hour, cursor.getHours()) &&
+            matches(parsed.dom, cursor.getDate()) &&
+            matches(parsed.month, cursor.getMonth() + 1) &&
+            matches(parsed.dow, cursor.getDay())) {
+            return cursor;
+        }
+        cursor.setMinutes(cursor.getMinutes() + 1);
+    }
+    return null;
+}
+export class Scheduler {
+    store;
+    onFire;
+    timer = null;
+    lastTickMinute = null;
+    destroyed = false;
+    constructor(store, onFire) {
+        this.store = store;
+        this.onFire = onFire;
+    }
+    start() {
+        if (this.destroyed || this.timer)
+            return;
+        this.scheduleNextTick();
+    }
+    stop() {
+        if (this.timer) {
+            clearTimeout(this.timer);
+            this.timer = null;
+        }
+    }
+    destroy() {
+        this.destroyed = true;
+        this.stop();
+    }
+    scheduleNextTick() {
+        if (this.destroyed)
+            return;
+        const now = new Date();
+        // Sleep until the start of the next minute (+50ms slack to avoid edge cases)
+        const msToNextMinute = (60 - now.getSeconds()) * 1000 - now.getMilliseconds() + 50;
+        this.timer = setTimeout(() => {
+            this.tick();
+            this.scheduleNextTick();
+        }, msToNextMinute);
+    }
+    tick() {
+        if (this.destroyed)
+            return;
+        const now = new Date();
+        now.setSeconds(0, 0);
+        const minuteKey = now.getTime();
+        if (minuteKey === this.lastTickMinute)
+            return;
+        this.lastTickMinute = minuteKey;
+        for (const job of this.store.listJobs()) {
+            if (!job.enabled)
+                continue;
+            try {
+                if (cronMatches(job.cron, now)) {
+                    this.onFire(job);
+                }
+            }
+            catch (e) {
+                console.error('schedule check failed for', job.id, e);
+            }
+        }
+    }
+}