agent-office 0.4.5 → 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/lib/pi-coding-server.d.ts

@@ -0,0 +1,20 @@
+import type { AgenticCodingServer, SessionMessage, AgentMode } from "./agentic-coding-server.js";
+export declare class PiCodingServer implements AgenticCodingServer {
+    private sessions;
+    private authStorage;
+    private modelRegistry;
+    private selectedModel;
+    private vendor;
+    private modelName;
+    constructor(vendor: string, model: string, apiKey: string);
+    /** Shared creation logic (no duplication) */
+    private createSessionInternal;
+    /** Fallback helper: returns cached session OR creates new one with the exact provided ID */
+    private ensureSession;
+    createSession(_title: string): Promise<string>;
+    deleteSession(sessionID: string): Promise<void>;
+    sendMessage(sessionID: string, text: string, agent: string, system: string): Promise<void>;
+    getMessages(sessionID: string, limit?: number): Promise<SessionMessage[]>;
+    revertSession(sessionID: string, messageID: string): Promise<void>;
+    getAgentModes(): Promise<AgentMode[]>;
+}

package/dist/lib/pi-coding-server.js

@@ -0,0 +1,162 @@
+import { createAgentSession, SessionManager, AuthStorage, ModelRegistry } from "@mariozechner/pi-coding-agent";
+import { getModel } from "@mariozechner/pi-ai";
+import crypto from "crypto";
+import path from "path";
+import fs from "fs/promises";
+export class PiCodingServer {
+    sessions = new Map();
+    authStorage;
+    modelRegistry;
+    selectedModel;
+    vendor;
+    modelName;
+    constructor(vendor, model, apiKey) {
+        if (!vendor || !model || !apiKey?.trim()) {
+            throw new Error("vendor, model, and apiKey are all required and must not be empty");
+        }
+        this.vendor = vendor.trim().toLowerCase();
+        this.modelName = model.trim();
+        this.authStorage = AuthStorage.create();
+        this.authStorage.setRuntimeApiKey(this.vendor, apiKey);
+        this.modelRegistry = new ModelRegistry(this.authStorage);
+        this.selectedModel = getModel(this.vendor, this.modelName);
+        if (!this.selectedModel) {
+            throw new Error(`Model '${this.modelName}' not found for provider '${this.vendor}'. ` +
+                `Check spelling or run 'pi /model' in a terminal.`);
+        }
+    }
+    /** Shared creation logic (no duplication) */
+    async createSessionInternal(sessionID) {
+        const workspace = path.join(process.cwd(), "workspaces", sessionID);
+        await fs.mkdir(workspace, { recursive: true });
+        const sessionManager = SessionManager.create(workspace);
+        const { session } = await createAgentSession({
+            cwd: workspace,
+            model: this.selectedModel,
+            thinkingLevel: "medium",
+            sessionManager,
+            authStorage: this.authStorage,
+            modelRegistry: this.modelRegistry,
+        });
+        return session;
+    }
+    /** Fallback helper: returns cached session OR creates new one with the exact provided ID */
+    async ensureSession(sessionID) {
+        let session = this.sessions.get(sessionID);
+        if (!session) {
+            session = await this.createSessionInternal(sessionID);
+            this.sessions.set(sessionID, session);
+        }
+        return session;
+    }
+    async createSession(_title) {
+        const sessionID = crypto.randomUUID();
+        const session = await this.createSessionInternal(sessionID);
+        this.sessions.set(sessionID, session);
+        return sessionID;
+    }
+    async deleteSession(sessionID) {
+        const session = this.sessions.get(sessionID);
+        if (session) {
+            session.dispose?.();
+            this.sessions.delete(sessionID);
+        }
+    }
+    async sendMessage(sessionID, text, agent, system) {
+        const session = await this.ensureSession(sessionID);
+        const prefix = agent ? `[Message from coworker ${agent}]: ` : "";
+        const message = `${prefix}${text}`;
+        // Set the system prompt if provided
+        if (system && system.trim()) {
+            session.agent.setSystemPrompt(system);
+        }
+        // Create a promise that resolves when the agent finishes processing
+        const completionPromise = new Promise((resolve) => {
+            const unsubscribe = session.subscribe((event) => {
+                if (event.type === "agent_end") {
+                    unsubscribe();
+                    resolve();
+                }
+            });
+            // Timeout after 5 minutes in case agent never finishes
+            setTimeout(() => {
+                unsubscribe();
+                resolve();
+            }, 5 * 60 * 1000);
+        });
+        // Send the prompt
+        await session.prompt(message);
+        // Wait for processing to complete
+        await completionPromise;
+    }
+    async getMessages(sessionID, limit = 100) {
+        const session = await this.ensureSession(sessionID);
+        const msgs = session.messages || [];
+        return msgs.slice(-limit).map((m) => {
+            let role = "assistant";
+            let parts = [];
+            if (m.role === "user") {
+                role = "user";
+                // User message content can be string or array
+                if (typeof m.content === "string") {
+                    parts = [{ type: "text", text: m.content }];
+                }
+                else if (Array.isArray(m.content)) {
+                    parts = m.content.map((c) => {
+                        if (c.type === "text")
+                            return { type: "text", text: c.text };
+                        return { type: c.type || "text", text: JSON.stringify(c) };
+                    });
+                }
+                else {
+                    parts = [{ type: "text", text: JSON.stringify(m.content) }];
+                }
+            }
+            else if (m.role === "assistant") {
+                role = "assistant";
+                // Assistant message content is always an array of TextContent | ThinkingContent | ToolCall
+                if (Array.isArray(m.content)) {
+                    parts = m.content.map((c) => {
+                        if (c.type === "text")
+                            return { type: "text", text: c.text };
+                        if (c.type === "thinking")
+                            return { type: "thinking", text: c.thinking };
+                        if (c.type === "toolCall")
+                            return { type: "toolCall", text: `[Tool: ${c.name}]` };
+                        return { type: c.type || "text", text: JSON.stringify(c) };
+                    });
+                }
+                else if (typeof m.content === "string") {
+                    parts = [{ type: "text", text: m.content }];
+                }
+            }
+            else {
+                // toolResult or other custom types
+                parts = [{ type: "text", text: JSON.stringify(m.content) }];
+            }
+            return {
+                id: m.id || m.entryId || crypto.randomUUID(),
+                role,
+                parts,
+            };
+        });
+    }
+    async revertSession(sessionID, messageID) {
+        const session = await this.ensureSession(sessionID);
+        try {
+            await session.navigateTree(messageID, { summarize: true });
+        }
+        catch (err) {
+            // Graceful: new/empty sessions can't revert → still succeed the call
+        }
+    }
+    async getAgentModes() {
+        return [
+            {
+                name: "coworker",
+                description: `${this.vendor.toUpperCase()} ${this.modelName} – fast agentic coding coworker`,
+                model: this.modelName,
+            },
+        ];
+    }
+}

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 {};