agent-office 0.4.6 → 0.4.7

package/dist/db/sqlite-storage.js

@@ -361,6 +361,208 @@ export class AgentOfficeSqliteStorage extends AgentOfficeStorageBase {
     `);
         stmt.run(cronJobId, executedAt.toISOString(), success ? 1 : 0, errorMessage ?? null);
     }
+    // Cron Requests
+    async listCronRequests(filters) {
+        let query = `
+      SELECT id, name, session_name, schedule, timezone, message, status, requested_at, reviewed_at, reviewed_by, reviewer_notes
+      FROM cron_requests
+      WHERE 1=1
+    `;
+        const params = [];
+        if (filters?.status) {
+            query += ` AND status = ?`;
+            params.push(filters.status);
+        }
+        if (filters?.sessionName) {
+            query += ` AND session_name = ?`;
+            params.push(filters.sessionName);
+        }
+        query += ` ORDER BY requested_at DESC`;
+        const stmt = this.db.prepare(query);
+        const rows = stmt.all(...params);
+        return rows.map(row => ({
+            ...row,
+            requested_at: new Date(row.requested_at),
+            reviewed_at: row.reviewed_at ? new Date(row.reviewed_at) : null,
+        }));
+    }
+    async getCronRequestById(id) {
+        const stmt = this.db.prepare(`
+      SELECT id, name, session_name, schedule, timezone, message, status, requested_at, reviewed_at, reviewed_by, reviewer_notes
+      FROM cron_requests WHERE id = ?
+    `);
+        const row = stmt.get(id);
+        if (!row)
+            return null;
+        return {
+            ...row,
+            requested_at: new Date(row.requested_at),
+            reviewed_at: row.reviewed_at ? new Date(row.reviewed_at) : null,
+        };
+    }
+    async createCronRequest(name, sessionName, schedule, timezone, message) {
+        const stmt = this.db.prepare(`
+      INSERT INTO cron_requests (name, session_name, schedule, timezone, message)
+      VALUES (?, ?, ?, ?, ?)
+      RETURNING id, name, session_name, schedule, timezone, message, status, requested_at, reviewed_at, reviewed_by, reviewer_notes
+    `);
+        const row = stmt.get(name, sessionName, schedule, timezone, message);
+        return {
+            ...row,
+            requested_at: new Date(row.requested_at),
+            reviewed_at: row.reviewed_at ? new Date(row.reviewed_at) : null,
+        };
+    }
+    async updateCronRequestStatus(id, status, reviewedBy, reviewerNotes) {
+        const stmt = this.db.prepare(`
+      UPDATE cron_requests
+      SET status = ?, reviewed_at = ?, reviewed_by = ?, reviewer_notes = ?
+      WHERE id = ?
+      RETURNING id, name, session_name, schedule, timezone, message, status, requested_at, reviewed_at, reviewed_by, reviewer_notes
+    `);
+        const row = stmt.get(status, new Date().toISOString(), reviewedBy, reviewerNotes ?? null, id);
+        if (!row)
+            return null;
+        return {
+            ...row,
+            requested_at: new Date(row.requested_at),
+            reviewed_at: row.reviewed_at ? new Date(row.reviewed_at) : null,
+        };
+    }
+    // Tasks
+    async listTasks() {
+        const stmt = this.db.prepare(`
+      SELECT id, title, description, assignee, column_name, dependencies, created_at, updated_at
+      FROM tasks
+      ORDER BY created_at DESC
+    `);
+        const rows = stmt.all();
+        return rows.map(row => ({
+            id: row.id,
+            title: row.title,
+            description: row.description,
+            assignee: row.assignee,
+            column: row.column_name,
+            dependencies: JSON.parse(row.dependencies),
+            created_at: new Date(row.created_at),
+            updated_at: new Date(row.updated_at),
+        }));
+    }
+    async getTaskById(id) {
+        const stmt = this.db.prepare(`
+      SELECT id, title, description, assignee, column_name, dependencies, created_at, updated_at
+      FROM tasks WHERE id = ?
+    `);
+        const row = stmt.get(id);
+        if (!row)
+            return null;
+        return {
+            id: row.id,
+            title: row.title,
+            description: row.description,
+            assignee: row.assignee,
+            column: row.column_name,
+            dependencies: JSON.parse(row.dependencies),
+            created_at: new Date(row.created_at),
+            updated_at: new Date(row.updated_at),
+        };
+    }
+    async createTask(title, description, assignee, column, dependencies) {
+        const now = new Date().toISOString();
+        const stmt = this.db.prepare(`
+      INSERT INTO tasks (title, description, assignee, column_name, dependencies, created_at, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?)
+      RETURNING id, title, description, assignee, column_name, dependencies, created_at, updated_at
+    `);
+        const row = stmt.get(title, description, assignee, column, JSON.stringify(dependencies), now, now);
+        return {
+            id: row.id,
+            title: row.title,
+            description: row.description,
+            assignee: row.assignee,
+            column: row.column_name,
+            dependencies: JSON.parse(row.dependencies),
+            created_at: new Date(row.created_at),
+            updated_at: new Date(row.updated_at),
+        };
+    }
+    async updateTask(id, updates) {
+        const setParts = [];
+        const values = [];
+        if (updates.title !== undefined) {
+            setParts.push('title = ?');
+            values.push(updates.title);
+        }
+        if (updates.description !== undefined) {
+            setParts.push('description = ?');
+            values.push(updates.description);
+        }
+        if (updates.assignee !== undefined) {
+            setParts.push('assignee = ?');
+            values.push(updates.assignee);
+        }
+        if (updates.column !== undefined) {
+            setParts.push('column_name = ?');
+            values.push(updates.column);
+        }
+        if (updates.dependencies !== undefined) {
+            setParts.push('dependencies = ?');
+            values.push(JSON.stringify(updates.dependencies));
+        }
+        if (setParts.length === 0)
+            return this.getTaskById(id);
+        setParts.push('updated_at = ?');
+        values.push(new Date().toISOString());
+        const sql = `UPDATE tasks SET ${setParts.join(', ')} WHERE id = ? RETURNING id, title, description, assignee, column_name, dependencies, created_at, updated_at`;
+        values.push(id);
+        const stmt = this.db.prepare(sql);
+        const row = stmt.get(...values);
+        if (!row)
+            return null;
+        return {
+            id: row.id,
+            title: row.title,
+            description: row.description,
+            assignee: row.assignee,
+            column: row.column_name,
+            dependencies: JSON.parse(row.dependencies),
+            created_at: new Date(row.created_at),
+            updated_at: new Date(row.updated_at),
+        };
+    }
+    async deleteTask(id) {
+        const stmt = this.db.prepare(`DELETE FROM tasks WHERE id = ?`);
+        stmt.run(id);
+    }
+    async searchTasks(query, filters) {
+        let sql = `
+      SELECT id, title, description, assignee, column_name, dependencies, created_at, updated_at
+      FROM tasks
+      WHERE (title LIKE ? OR description LIKE ?)
+    `;
+        const params = [`${query}%`, `${query}%`];
+        if (filters?.assignee) {
+            sql += ` AND assignee = ?`;
+            params.push(filters.assignee);
+        }
+        if (filters?.column) {
+            sql += ` AND column_name = ?`;
+            params.push(filters.column);
+        }
+        sql += ` ORDER BY created_at DESC`;
+        const stmt = this.db.prepare(sql);
+        const rows = stmt.all(...params);
+        return rows.map(row => ({
+            id: row.id,
+            title: row.title,
+            description: row.description,
+            assignee: row.assignee,
+            column: row.column_name,
+            dependencies: JSON.parse(row.dependencies),
+            created_at: new Date(row.created_at),
+            updated_at: new Date(row.updated_at),
+        }));
+    }
     // Migrations
     async runMigrations() {
         const MIGRATIONS = [
@@ -488,6 +690,45 @@ export class AgentOfficeSqliteStorage extends AgentOfficeStorageBase {
                 name: "add_notified_to_messages",
                 sql: `
           ALTER TABLE messages ADD COLUMN notified INTEGER NOT NULL DEFAULT 0;
+        `,
+            },
+            {
+                version: 10,
+                name: "create_tasks_table",
+                sql: `
+          CREATE TABLE IF NOT EXISTS tasks (
+            id           INTEGER PRIMARY KEY AUTOINCREMENT,
+            title        TEXT NOT NULL,
+            description  TEXT NOT NULL,
+            assignee     TEXT,
+            column_name  TEXT NOT NULL,
+            dependencies TEXT NOT NULL DEFAULT '[]',
+            created_at   DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+            updated_at   DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
+          );
+          CREATE INDEX IF NOT EXISTS idx_tasks_assignee ON tasks(assignee);
+          CREATE INDEX IF NOT EXISTS idx_tasks_column ON tasks(column_name);
+        `,
+            },
+            {
+                version: 11,
+                name: "create_cron_requests_table",
+                sql: `
+          CREATE TABLE IF NOT EXISTS cron_requests (
+            id              INTEGER PRIMARY KEY AUTOINCREMENT,
+            name            TEXT NOT NULL,
+            session_name    TEXT NOT NULL REFERENCES sessions(name) ON DELETE CASCADE,
+            schedule        TEXT NOT NULL,
+            timezone        TEXT,
+            message         TEXT NOT NULL,
+            status          TEXT NOT NULL DEFAULT 'pending',
+            requested_at    DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+            reviewed_at     DATETIME,
+            reviewed_by     TEXT,
+            reviewer_notes  TEXT
+          );
+          CREATE INDEX IF NOT EXISTS idx_cron_requests_session_name ON cron_requests(session_name);
+          CREATE INDEX IF NOT EXISTS idx_cron_requests_status ON cron_requests(status);
         `,
             },
         ];

package/dist/db/storage-base.d.ts

@@ -1,4 +1,4 @@
-import type { AgentOfficeStorage, SessionRow, ConfigRow, MessageRow, CronJobRow, CronHistoryRow } from "./index.js";
+import type { AgentOfficeStorage, SessionRow, ConfigRow, MessageRow, CronJobRow, CronHistoryRow, CronRequestRow, TaskRow } from "./index.js";
 import type { WatchListener, WatchState, SenderInfo } from "./storage.js";
 export { WatchListener, WatchState, SenderInfo };
 export declare abstract class AgentOfficeStorageBase implements AgentOfficeStorage {
@@ -44,6 +44,22 @@ export declare abstract class AgentOfficeStorageBase implements AgentOfficeStora
     abstract cronJobExistsForSession(name: string, sessionName: string): Promise<boolean>;
     abstract listCronHistory(cronJobId: number, limit: number): Promise<CronHistoryRow[]>;
     abstract createCronHistory(cronJobId: number, executedAt: Date, success: boolean, errorMessage?: string): Promise<void>;
+    abstract listCronRequests(filters?: {
+        status?: string;
+        sessionName?: string;
+    }): Promise<CronRequestRow[]>;
+    abstract getCronRequestById(id: number): Promise<CronRequestRow | null>;
+    abstract createCronRequest(name: string, sessionName: string, schedule: string, timezone: string | null, message: string): Promise<CronRequestRow>;
+    abstract updateCronRequestStatus(id: number, status: "approved" | "rejected", reviewedBy: string, reviewerNotes?: string): Promise<CronRequestRow | null>;
+    abstract listTasks(): Promise<TaskRow[]>;
+    abstract getTaskById(id: number): Promise<TaskRow | null>;
+    abstract createTask(title: string, description: string, assignee: string | null, column: string, dependencies: number[]): Promise<TaskRow>;
+    abstract updateTask(id: number, updates: Partial<Pick<TaskRow, 'title' | 'description' | 'assignee' | 'column' | 'dependencies'>>): Promise<TaskRow | null>;
+    abstract deleteTask(id: number): Promise<void>;
+    abstract searchTasks(query: string, filters?: {
+        assignee?: string;
+        column?: string;
+    }): Promise<TaskRow[]>;
     abstract runMigrations(): Promise<void>;
     abstract createMessageImpl(from: string, to: string, body: string): Promise<MessageRow>;
     /**

package/dist/db/storage.d.ts

@@ -1,4 +1,4 @@
-import type { SessionRow, ConfigRow, MessageRow, CronJobRow, CronHistoryRow } from "./index.js";
+import type { SessionRow, ConfigRow, MessageRow, CronJobRow, CronHistoryRow, CronRequestRow } from "./index.js";
 export interface SenderInfo {
     lastSent: string;
 }
@@ -54,5 +54,21 @@ export interface AgentOfficeStorage {
     cronJobExistsForSession(name: string, sessionName: string): Promise<boolean>;
     listCronHistory(cronJobId: number, limit: number): Promise<CronHistoryRow[]>;
     createCronHistory(cronJobId: number, executedAt: Date, success: boolean, errorMessage?: string): Promise<void>;
+    listCronRequests(filters?: {
+        status?: string;
+        sessionName?: string;
+    }): Promise<CronRequestRow[]>;
+    getCronRequestById(id: number): Promise<CronRequestRow | null>;
+    createCronRequest(name: string, sessionName: string, schedule: string, timezone: string | null, message: string): Promise<CronRequestRow>;
+    updateCronRequestStatus(id: number, status: "approved" | "rejected", reviewedBy: string, reviewerNotes?: string): Promise<CronRequestRow | null>;
+    listTasks(): Promise<import("./index.js").TaskRow[]>;
+    getTaskById(id: number): Promise<import("./index.js").TaskRow | null>;
+    createTask(title: string, description: string, assignee: string | null, column: string, dependencies: number[]): Promise<import("./index.js").TaskRow>;
+    updateTask(id: number, updates: Partial<Pick<import("./index.js").TaskRow, 'title' | 'description' | 'assignee' | 'column' | 'dependencies'>>): Promise<import("./index.js").TaskRow | null>;
+    deleteTask(id: number): Promise<void>;
+    searchTasks(query: string, filters?: {
+        assignee?: string;
+        column?: string;
+    }): Promise<import("./index.js").TaskRow[]>;
     runMigrations(): Promise<void>;
 }

package/dist/manage/app.js

@@ -10,15 +10,17 @@ import { MyMail } from "./components/MyMail.js";
 import { SessionSidebar } from "./components/SessionSidebar.js";
 import { MenuSelect } from "./components/MenuSelect.js";
 import { CronList } from "./components/CronList.js";
+import { CronRequests } from "./components/CronRequests.js";
 const MENU_OPTIONS = [
     { label: "Send message", value: "send-message" },
     { label: "My mail", value: "my-mail" },
     { label: "Coworkers", value: "list" },
     { label: "Cron jobs", value: "cron" },
+    { label: "Cron requests", value: "cron-requests" },
     { label: "My profile", value: "profile" },
     { label: "Quit", value: "quit" },
 ];
-const SUB_SCREENS = ["list", "send-message", "my-mail", "profile", "cron"];
+const SUB_SCREENS = ["list", "send-message", "my-mail", "profile", "cron", "cron-requests"];
 const FOOTER_HINTS = {
     connecting: "",
     "auth-error": "",
@@ -28,6 +30,7 @@ const FOOTER_HINTS = {
     "my-mail": "↑↓ select message · r reply · m mark read · a mark all read · s sent tab · Esc back",
     "profile": "Enter submit · Esc back to menu",
     cron: "↑↓ navigate · c create · d delete · e enable/disable · h history · Esc back",
+    "cron-requests": "↑↓ navigate · a approve · r reject · v view · f filter · Esc back",
 };
 function Header({ serverUrl, unreadCount }) {
     return (_jsxs(Box, { borderStyle: "single", borderColor: "cyan", paddingX: 1, justifyContent: "space-between", children: [_jsx(Text, { bold: true, color: "cyan", children: "agent-office" }), _jsxs(Box, { gap: 2, children: [unreadCount > 0 && (_jsxs(Text, { color: "yellow", bold: true, children: ["\u2709 ", unreadCount, " unread"] })), _jsx(Text, { dimColor: true, children: serverUrl })] })] }));
@@ -117,6 +120,8 @@ export function App({ serverUrl, password }) {
                 return (_jsx(Box, { height: contentHeight, flexDirection: "column", paddingX: 2, paddingY: 1, children: _jsx(MyMail, { serverUrl: serverUrl, password: password, onBack: goBack, contentHeight: contentHeight - 2, onReply: (name) => { setReplyTo(name); setScreen("send-message"); } }) }));
             case "cron":
                 return (_jsx(Box, { height: contentHeight, flexDirection: "column", paddingX: 2, paddingY: 1, children: _jsx(CronList, { serverUrl: serverUrl, password: password, onBack: goBack, contentHeight: contentHeight - 2 }) }));
+            case "cron-requests":
+                return (_jsx(Box, { height: contentHeight, flexDirection: "column", paddingX: 2, paddingY: 1, children: _jsx(CronRequests, { serverUrl: serverUrl, password: password, onBack: goBack, contentHeight: contentHeight - 2 }) }));
         }
     };
     return (_jsxs(Box, { flexDirection: "column", width: termWidth, children: [_jsx(Header, { serverUrl: serverUrl, unreadCount: unreadCount }), renderContent(), screen !== "connecting" && (_jsx(Footer, { hint: FOOTER_HINTS[screen] }))] }));

package/dist/manage/components/CronRequests.d.ts

@@ -0,0 +1,8 @@
+interface CronRequestsProps {
+    serverUrl: string;
+    password: string;
+    onBack: () => void;
+    contentHeight: number;
+}
+export declare function CronRequests({ serverUrl, password, onBack, contentHeight }: CronRequestsProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/manage/components/CronRequests.js

@@ -0,0 +1,181 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { useEffect, useState, useCallback } from "react";
+import { Box, Text, useInput } from "ink";
+import { TextInput, Spinner, ConfirmInput } from "@inkjs/ui";
+import { useApi, useAsyncState } from "../hooks/useApi.js";
+export function CronRequests({ serverUrl, password, onBack, contentHeight }) {
+    const { listCronRequests, approveCronRequest, rejectCronRequest } = useApi(serverUrl, password);
+    const { data: requests, loading, error: loadError, run } = useAsyncState();
+    const [cursor, setCursor] = useState(0);
+    const [mode, setMode] = useState("list");
+    const [actionMsg, setActionMsg] = useState(null);
+    const [actionError, setActionError] = useState(null);
+    const [rejectNotes, setRejectNotes] = useState("");
+    const [showAll, setShowAll] = useState(false);
+    const filteredRequests = (requests ?? []).filter((r) => showAll || r.status === "pending");
+    const reload = useCallback(() => {
+        void run(() => listCronRequests(showAll ? undefined : { status: "pending" }));
+    }, [showAll]);
+    useEffect(() => {
+        reload();
+    }, [showAll]);
+    useEffect(() => {
+        if (filteredRequests.length > 0) {
+            setCursor((c) => Math.min(c, filteredRequests.length - 1));
+        }
+    }, [filteredRequests.length]);
+    useInput((input, key) => {
+        if (key.escape && mode === "list") {
+            onBack();
+            return;
+        }
+        if (key.escape && (mode === "confirm-approve" || mode === "confirm-reject" || mode === "reject-notes" || mode === "view-message")) {
+            setMode("list");
+            setRejectNotes("");
+            return;
+        }
+        if (loading)
+            return;
+        if (mode === "list") {
+            if (key.upArrow)
+                setCursor((c) => Math.max(0, c - 1));
+            if (key.downArrow)
+                setCursor((c) => Math.min(filteredRequests.length - 1, c + 1));
+            if (filteredRequests.length > 0) {
+                const selected = filteredRequests[cursor];
+                if (input === "a" && selected?.status === "pending") {
+                    setActionError(null);
+                    setActionMsg(null);
+                    setMode("confirm-approve");
+                }
+                if (input === "r" && selected?.status === "pending") {
+                    setActionError(null);
+                    setActionMsg(null);
+                    setRejectNotes("");
+                    setMode("reject-notes");
+                }
+                if (input === "v") {
+                    setMode("view-message");
+                }
+            }
+            if (input === "f") {
+                setShowAll((prev) => !prev);
+            }
+        }
+        if (mode === "confirm-approve") {
+            if (key.return || input === "y") {
+                handleApprove();
+            }
+            if (input === "n" || key.escape) {
+                setMode("list");
+            }
+            return;
+        }
+        if (mode === "confirm-reject") {
+            if (key.return || input === "y") {
+                handleReject();
+            }
+            if (input === "n" || key.escape) {
+                setMode("list");
+                setRejectNotes("");
+            }
+            return;
+        }
+    });
+    const handleApprove = async () => {
+        const selected = filteredRequests[cursor];
+        if (!selected)
+            return;
+        setMode("approving");
+        try {
+            await approveCronRequest(selected.id);
+            setActionMsg(`Cron request "${selected.name}" approved and scheduled.`);
+            setMode("list");
+            reload();
+        }
+        catch (err) {
+            setActionError(err instanceof Error ? err.message : String(err));
+            setMode("list");
+        }
+    };
+    const handleReject = async () => {
+        const selected = filteredRequests[cursor];
+        if (!selected)
+            return;
+        setMode("rejecting");
+        try {
+            await rejectCronRequest(selected.id, rejectNotes || undefined);
+            setActionMsg(`Cron request "${selected.name}" rejected.`);
+            setMode("list");
+            setRejectNotes("");
+            reload();
+        }
+        catch (err) {
+            setActionError(err instanceof Error ? err.message : String(err));
+            setMode("list");
+            setRejectNotes("");
+        }
+    };
+    const formatDate = (dateStr) => {
+        try {
+            return new Date(dateStr).toLocaleString();
+        }
+        catch {
+            return dateStr;
+        }
+    };
+    const statusColor = (status) => {
+        switch (status) {
+            case "pending": return "yellow";
+            case "approved": return "green";
+            case "rejected": return "red";
+            default: return "white";
+        }
+    };
+    if (loading && filteredRequests.length === 0) {
+        return (_jsx(Box, { height: contentHeight, alignItems: "center", justifyContent: "center", children: _jsx(Spinner, { label: "Loading cron requests..." }) }));
+    }
+    if (loadError) {
+        return (_jsxs(Box, { height: contentHeight, flexDirection: "column", gap: 1, children: [_jsx(Text, { color: "red", bold: true, children: "Error" }), _jsx(Text, { children: loadError })] }));
+    }
+    const renderActionPanel = () => {
+        if (mode === "approving") {
+            return (_jsx(Box, { borderStyle: "round", borderColor: "green", paddingX: 1, marginBottom: 1, children: _jsx(Spinner, { label: `Approving "${filteredRequests[cursor]?.name}"...` }) }));
+        }
+        if (mode === "rejecting") {
+            return (_jsx(Box, { borderStyle: "round", borderColor: "red", paddingX: 1, marginBottom: 1, children: _jsx(Spinner, { label: `Rejecting "${filteredRequests[cursor]?.name}"...` }) }));
+        }
+        if (mode === "confirm-approve" && filteredRequests[cursor]) {
+            const req = filteredRequests[cursor];
+            return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "green", paddingX: 1, marginBottom: 1, children: [_jsx(Text, { bold: true, color: "green", children: "Approve Cron Request" }), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsxs(Text, { children: ["Approve ", _jsx(Text, { color: "cyan", bold: true, children: req.name }), " from ", _jsx(Text, { color: "magenta", children: req.session_name }), "?"] }), _jsxs(Text, { dimColor: true, children: ["Schedule: ", req.schedule] })] }), _jsx(Box, { marginTop: 1, children: _jsx(ConfirmInput, { defaultChoice: "cancel", onConfirm: () => void handleApprove(), onCancel: () => setMode("list") }) })] }));
+        }
+        if (mode === "confirm-reject" && filteredRequests[cursor]) {
+            const req = filteredRequests[cursor];
+            return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "red", paddingX: 1, marginBottom: 1, children: [_jsx(Text, { bold: true, color: "red", children: "Reject Cron Request" }), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsxs(Text, { children: ["Reject ", _jsx(Text, { color: "cyan", bold: true, children: req.name }), " from ", _jsx(Text, { color: "magenta", children: req.session_name }), "?"] }), rejectNotes && _jsxs(Text, { dimColor: true, children: ["Notes: ", rejectNotes] })] }), _jsx(Box, { marginTop: 1, children: _jsx(ConfirmInput, { defaultChoice: "cancel", onConfirm: () => void handleReject(), onCancel: () => { setMode("list"); setRejectNotes(""); } }) })] }));
+        }
+        return null;
+    };
+    const renderRejectNotes = () => {
+        if (mode !== "reject-notes")
+            return null;
+        return (_jsxs(Box, { flexDirection: "column", gap: 1, children: [_jsxs(Box, { gap: 2, children: [_jsx(Text, { bold: true, color: "red", children: "Reject Cron Request" }), _jsx(Text, { dimColor: true, children: filteredRequests[cursor]?.name })] }), _jsxs(Box, { gap: 1, children: [_jsx(Text, { children: "Reason (optional, Enter to skip): " }), _jsx(TextInput, { placeholder: "e.g. Schedule too frequent", onSubmit: (v) => {
+                                setRejectNotes(v);
+                                setMode("confirm-reject");
+                            } }, "reject-notes")] }), _jsx(Text, { dimColor: true, children: "Esc cancel" })] }));
+    };
+    const renderViewMessage = () => {
+        if (mode !== "view-message")
+            return null;
+        const selected = filteredRequests[cursor];
+        if (!selected)
+            return null;
+        return (_jsxs(Box, { flexDirection: "column", gap: 1, children: [_jsxs(Box, { gap: 2, children: [_jsx(Text, { bold: true, children: "Request Details" }), _jsx(Text, { dimColor: true, children: selected.name })] }), _jsxs(Box, { borderStyle: "round", borderColor: "cyan", paddingX: 1, paddingY: 0, flexDirection: "column", children: [_jsxs(Text, { children: ["From: ", _jsx(Text, { color: "magenta", bold: true, children: selected.session_name })] }), _jsxs(Text, { children: ["Schedule: ", _jsx(Text, { bold: true, children: selected.schedule })] }), selected.timezone && _jsxs(Text, { children: ["Timezone: ", selected.timezone] }), _jsxs(Text, { children: ["Status: ", _jsx(Text, { color: statusColor(selected.status), bold: true, children: selected.status })] }), _jsxs(Text, { children: ["Requested: ", formatDate(selected.requested_at)] }), selected.reviewed_at && _jsxs(Text, { children: ["Reviewed: ", formatDate(selected.reviewed_at), " by ", selected.reviewed_by] }), selected.reviewer_notes && _jsxs(Text, { children: ["Notes: ", selected.reviewer_notes] }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { bold: true, children: "Message:" }) }), _jsx(Text, { wrap: "wrap", children: selected.message })] }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "Esc back" }) })] }));
+    };
+    const actionPanel = renderActionPanel();
+    const panelHeight = actionPanel ? 5 : 0;
+    const tableHeight = contentHeight - panelHeight - 5;
+    return (_jsxs(Box, { flexDirection: "column", gap: 0, children: [renderRejectNotes(), renderViewMessage(), (mode === "list" || mode === "confirm-approve" || mode === "confirm-reject" || mode === "approving" || mode === "rejecting") && (_jsxs(_Fragment, { children: [_jsxs(Box, { gap: 2, marginBottom: 1, children: [_jsx(Text, { bold: true, children: "Cron Requests" }), _jsxs(Text, { dimColor: true, children: ["[", filteredRequests.length, " ", showAll ? "total" : "pending", "]"] }), loading && _jsx(Spinner, {})] }), actionMsg && (_jsx(Box, { marginBottom: 1, children: _jsx(Text, { color: "green", children: actionMsg }) })), actionError && (_jsx(Box, { marginBottom: 1, children: _jsx(Text, { color: "red", children: actionError }) })), actionPanel, filteredRequests.length === 0 ? (_jsx(Box, { height: tableHeight, alignItems: "center", justifyContent: "center", children: _jsx(Text, { dimColor: true, children: showAll ? "No cron requests found." : "No pending cron requests. Press f to show all." }) })) : (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { gap: 2, marginBottom: 1, children: [_jsx(Text, { bold: true, color: "cyan", children: "  NAME".padEnd(20) }), _jsx(Text, { bold: true, color: "cyan", children: "COWORKER".padEnd(15) }), _jsx(Text, { bold: true, color: "cyan", children: "SCHEDULE".padEnd(20) }), _jsx(Text, { bold: true, color: "cyan", children: "REQUESTED".padEnd(22) }), _jsx(Text, { bold: true, color: "cyan", children: "STATUS" })] }), filteredRequests.map((req, idx) => {
+                                const selected = idx === cursor;
+                                return (_jsxs(Box, { gap: 2, children: [_jsxs(Box, { width: 20, children: [_jsx(Text, { color: selected ? "cyan" : undefined, children: selected ? "▶ " : "  " }), _jsx(Text, { color: selected ? "cyan" : "green", bold: selected, children: req.name })] }), _jsx(Box, { width: 15, children: _jsx(Text, { color: selected ? "magenta" : undefined, dimColor: !selected, children: req.session_name.padEnd(15) }) }), _jsx(Box, { width: 20, children: _jsx(Text, { dimColor: !selected, children: req.schedule.padEnd(20) }) }), _jsx(Box, { width: 22, children: _jsx(Text, { dimColor: !selected, children: formatDate(req.requested_at).padEnd(22) }) }), _jsx(Text, { color: statusColor(req.status), bold: selected, children: req.status })] }, req.id));
+                            })] })), _jsx(Box, { marginTop: 1, children: _jsxs(Text, { dimColor: true, children: ["a approve \u00B7 r reject \u00B7 v view details \u00B7 f ", showAll ? "show pending only" : "show all", " \u00B7 Esc back"] }) })] }))] }));
+}

package/dist/manage/hooks/useApi.d.ts

@@ -55,6 +55,19 @@ export interface CronHistoryEntry {
     success: boolean;
     error_message: string | null;
 }
+export interface CronRequest {
+    id: number;
+    name: string;
+    session_name: string;
+    schedule: string;
+    timezone: string | null;
+    message: string;
+    status: "pending" | "approved" | "rejected";
+    requested_at: string;
+    reviewed_at: string | null;
+    reviewed_by: string | null;
+    reviewer_notes: string | null;
+}
 export declare function useApi(serverUrl: string, password: string): {
     listSessions: () => Promise<Session[]>;
     createSession: (name: string, agent: string) => Promise<Session>;
@@ -116,6 +129,15 @@ export declare function useApi(serverUrl: string, password: string): {
     enableCron: (id: number) => Promise<CronJob>;
     disableCron: (id: number) => Promise<CronJob>;
     getCronHistory: (id: number, limit?: number) => Promise<CronHistoryEntry[]>;
+    listCronRequests: (filters?: {
+        status?: string;
+        sessionName?: string;
+    }) => Promise<CronRequest[]>;
+    approveCronRequest: (id: number, notes?: string) => Promise<{
+        request: CronRequest;
+        cron_job: CronJob;
+    }>;
+    rejectCronRequest: (id: number, notes?: string) => Promise<CronRequest>;
 };
 export declare function useAsyncState<T>(): {
     run: (fn: () => Promise<T>) => Promise<T | null>;

package/dist/manage/hooks/useApi.js

@@ -115,6 +115,21 @@ export function useApi(serverUrl, password) {
     const getCronHistory = useCallback(async (id, limit = 10) => {
         return apiFetch(`${base}/crons/${id}/history?limit=${limit}`, password);
     }, [base, password]);
+    const listCronRequests = useCallback(async (filters) => {
+        const params = new URLSearchParams();
+        if (filters?.status)
+            params.set("status", filters.status);
+        if (filters?.sessionName)
+            params.set("session_name", filters.sessionName);
+        const query = params.toString() ? `?${params.toString()}` : "";
+        return apiFetch(`${base}/cron-requests${query}`, password);
+    }, [base, password]);
+    const approveCronRequest = useCallback(async (id, notes) => {
+        return apiFetch(`${base}/cron-requests/${id}/approve`, password, { method: "POST", body: JSON.stringify({ notes }) });
+    }, [base, password]);
+    const rejectCronRequest = useCallback(async (id, notes) => {
+        return apiFetch(`${base}/cron-requests/${id}/reject`, password, { method: "POST", body: JSON.stringify({ notes }) });
+    }, [base, password]);
     return {
         listSessions,
         createSession,
@@ -138,6 +153,9 @@ export function useApi(serverUrl, password) {
         enableCron,
         disableCron,
         getCronHistory,
+        listCronRequests,
+        approveCronRequest,
+        rejectCronRequest,
     };
 }
 export function useAsyncState() {