agent-office 0.0.0 → 0.0.2

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

@@ -0,0 +1,6 @@
+interface SessionSidebarProps {
+    serverUrl: string;
+    password: string;
+}
+export declare function SessionSidebar({ serverUrl, password }: SessionSidebarProps): import("react/jsx-runtime").JSX.Element | null;
+export {};

package/dist/manage/components/SessionSidebar.js

@@ -0,0 +1,18 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState, useEffect } from "react";
+import { Box, Text } from "ink";
+import { useApi } from "../hooks/useApi.js";
+export function SessionSidebar({ serverUrl, password }) {
+    const { listSessions } = useApi(serverUrl, password);
+    const [sessions, setSessions] = useState([]);
+    useEffect(() => {
+        listSessions().then((s) => setSessions(s));
+    }, [listSessions]);
+    if (sessions.length === 0)
+        return null;
+    return (_jsxs(Box, { borderStyle: "single", borderColor: "cyan", paddingX: 1, flexDirection: "column", gap: 0, children: [_jsx(Text, { bold: true, color: "cyan", children: "Sessions" }), sessions.map((session, i) => (_jsxs(Box, { gap: 1, children: [_jsx(Text, { color: getNodeColor(i), children: "\u25CF" }), _jsx(Text, { children: session.name })] }, session.id)))] }));
+}
+function getNodeColor(index) {
+    const colors = ["green", "blue", "yellow", "magenta", "cyan", "red", "white"];
+    return colors[index % colors.length];
+}

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

@@ -3,8 +3,14 @@ export interface Session {
     name: string;
     session_id: string;
     agent_code: string;
+    mode: string | null;
     created_at: string;
 }
+export interface AppMode {
+    name: string;
+    description: string;
+    model: string;
+}
 export interface MessagePart {
     type: "text";
     text: string;
@@ -13,9 +19,40 @@ export interface SessionMessage {
     role: "user" | "assistant";
     parts: MessagePart[];
 }
+export interface MailMessage {
+    id: number;
+    from_name: string;
+    to_name: string;
+    body: string;
+    read: boolean;
+    injected: boolean;
+    created_at: string;
+}
+export interface Config {
+    [key: string]: string;
+}
+export interface CronJob {
+    id: number;
+    name: string;
+    session_name: string;
+    schedule: string;
+    timezone: string | null;
+    message: string;
+    enabled: boolean;
+    created_at: string;
+    last_run: string | null;
+    next_run: string | null;
+}
+export interface CronHistoryEntry {
+    id: number;
+    cron_job_id: number;
+    executed_at: string;
+    success: boolean;
+    error_message: string | null;
+}
 export declare function useApi(serverUrl: string, password: string): {
     listSessions: () => Promise<Session[]>;
-    createSession: (name: string) => Promise<Session>;
+    createSession: (name: string, mode?: string) => Promise<Session>;
     deleteSession: (name: string) => Promise<void>;
     checkHealth: () => Promise<boolean>;
     getMessages: (name: string, limit?: number) => Promise<SessionMessage[]>;
@@ -24,6 +61,42 @@ export declare function useApi(serverUrl: string, password: string): {
         messageID: string;
     }>;
     regenerateCode: (name: string) => Promise<Session>;
+    getConfig: () => Promise<Config>;
+    setConfig: (key: string, value: string) => Promise<{
+        ok: boolean;
+        key: string;
+        value: string;
+    }>;
+    getMailMessages: (name: string, options?: {
+        sent?: boolean;
+        unreadOnly?: boolean;
+    }) => Promise<MailMessage[]>;
+    sendMailMessage: (from: string, to: string[], body: string) => Promise<{
+        ok: boolean;
+        results: Array<{
+            to: string;
+            messageId: number;
+            injected: boolean;
+        }>;
+    }>;
+    markMessageRead: (id: number) => Promise<MailMessage>;
+    getModes: () => Promise<AppMode[]>;
+    listCrons: (sessionName?: string) => Promise<CronJob[]>;
+    createCron: (data: {
+        name: string;
+        session_name: string;
+        schedule: string;
+        message: string;
+        timezone?: string;
+    }) => Promise<CronJob>;
+    deleteCron: (id: number) => Promise<{
+        deleted: boolean;
+        id: number;
+        name: string;
+    }>;
+    enableCron: (id: number) => Promise<CronJob>;
+    disableCron: (id: number) => Promise<CronJob>;
+    getCronHistory: (id: number, limit?: number) => Promise<CronHistoryEntry[]>;
 };
 export declare function useAsyncState<T>(): {
     run: (fn: () => Promise<T>) => Promise<T | null>;

package/dist/manage/hooks/useApi.js

@@ -28,12 +28,15 @@ export function useApi(serverUrl, password) {
     const listSessions = useCallback(async () => {
         return apiFetch(`${base}/sessions`, password);
     }, [base, password]);
-    const createSession = useCallback(async (name) => {
+    const createSession = useCallback(async (name, mode) => {
         return apiFetch(`${base}/sessions`, password, {
             method: "POST",
-            body: JSON.stringify({ name }),
+            body: JSON.stringify({ name, ...(mode ? { mode } : {}) }),
         });
     }, [base, password]);
+    const getModes = useCallback(async () => {
+        return apiFetch(`${base}/modes`, password);
+    }, [base, password]);
     const deleteSession = useCallback(async (name) => {
         await apiFetch(`${base}/sessions/${encodeURIComponent(name)}`, password, {
             method: "DELETE",
@@ -57,7 +60,70 @@ export function useApi(serverUrl, password) {
     const regenerateCode = useCallback(async (name) => {
         return apiFetch(`${base}/sessions/${encodeURIComponent(name)}/regenerate-code`, password, { method: "POST" });
     }, [base, password]);
-    return { listSessions, createSession, deleteSession, checkHealth, getMessages, injectText, regenerateCode };
+    const getConfig = useCallback(async () => {
+        return apiFetch(`${base}/config`, password);
+    }, [base, password]);
+    const setConfig = useCallback(async (key, value) => {
+        return apiFetch(`${base}/config`, password, { method: "PUT", body: JSON.stringify({ key, value }) });
+    }, [base, password]);
+    const getMailMessages = useCallback(async (name, options) => {
+        const params = new URLSearchParams();
+        if (options?.sent)
+            params.set("sent", "true");
+        if (options?.unreadOnly)
+            params.set("unread_only", "true");
+        const query = params.toString() ? `?${params.toString()}` : "";
+        return apiFetch(`${base}/messages/${encodeURIComponent(name)}${query}`, password);
+    }, [base, password]);
+    const sendMailMessage = useCallback(async (from, to, body) => {
+        return apiFetch(`${base}/messages`, password, { method: "POST", body: JSON.stringify({ from, to, body }) });
+    }, [base, password]);
+    const markMessageRead = useCallback(async (id) => {
+        return apiFetch(`${base}/messages/${id}/read`, password, { method: "POST" });
+    }, [base, password]);
+    const listCrons = useCallback(async (sessionName) => {
+        const params = sessionName ? `?session_name=${encodeURIComponent(sessionName)}` : "";
+        return apiFetch(`${base}/crons${params}`, password);
+    }, [base, password]);
+    const createCron = useCallback(async (data) => {
+        return apiFetch(`${base}/crons`, password, {
+            method: "POST",
+            body: JSON.stringify(data),
+        });
+    }, [base, password]);
+    const deleteCron = useCallback(async (id) => {
+        return apiFetch(`${base}/crons/${id}`, password, { method: "DELETE" });
+    }, [base, password]);
+    const enableCron = useCallback(async (id) => {
+        return apiFetch(`${base}/crons/${id}/enable`, password, { method: "POST" });
+    }, [base, password]);
+    const disableCron = useCallback(async (id) => {
+        return apiFetch(`${base}/crons/${id}/disable`, password, { method: "POST" });
+    }, [base, password]);
+    const getCronHistory = useCallback(async (id, limit = 10) => {
+        return apiFetch(`${base}/crons/${id}/history?limit=${limit}`, password);
+    }, [base, password]);
+    return {
+        listSessions,
+        createSession,
+        deleteSession,
+        checkHealth,
+        getMessages,
+        injectText,
+        regenerateCode,
+        getConfig,
+        setConfig,
+        getMailMessages,
+        sendMailMessage,
+        markMessageRead,
+        getModes,
+        listCrons,
+        createCron,
+        deleteCron,
+        enableCron,
+        disableCron,
+        getCronHistory,
+    };
 }
 export function useAsyncState() {
     const [state, setState] = useState({

package/dist/server/cron.d.ts

@@ -0,0 +1,24 @@
+import type { Sql } from "../db/index.js";
+import type { OpencodeClient } from "../lib/opencode.js";
+import type { CronJobRow } from "../db/index.js";
+interface CronSchedulerOptions {
+    onJobExecuted?: (jobId: number, success: boolean, error?: string) => void;
+}
+export declare class CronScheduler {
+    private options;
+    private activeJobs;
+    private sql;
+    private opencode;
+    private started;
+    constructor(options?: CronSchedulerOptions);
+    start(sql: Sql, opencode: OpencodeClient): Promise<void>;
+    stop(): void;
+    private addJob;
+    private executeJob;
+    addCronJob(job: CronJobRow): void;
+    removeCronJob(jobId: number): void;
+    enableCronJob(job: CronJobRow): void;
+    disableCronJob(jobId: number): void;
+    isTracking(jobId: number): boolean;
+}
+export {};

package/dist/server/cron.js

@@ -0,0 +1,121 @@
+import { Cron } from "croner";
+const CRON_INJECTION_BLURB = [
+    ``,
+    `---`,
+    `You have a scheduled cron job trigger. Please review the injected message above`,
+    `and take appropriate action.`,
+].join("\n");
+export class CronScheduler {
+    options;
+    activeJobs = new Map();
+    sql = null;
+    opencode = null;
+    started = false;
+    constructor(options = {}) {
+        this.options = options;
+    }
+    async start(sql, opencode) {
+        if (this.started)
+            return;
+        this.sql = sql;
+        this.opencode = opencode;
+        const rows = await sql `
+      SELECT id, name, schedule, timezone, message, session_name
+      FROM cron_jobs
+      WHERE enabled = TRUE
+    `;
+        for (const job of rows) {
+            this.addJob(job);
+        }
+        this.started = true;
+        console.log(`Cron scheduler started: tracking ${rows.length} active jobs`);
+    }
+    stop() {
+        for (const cronInst of this.activeJobs.values()) {
+            cronInst.cron.stop();
+        }
+        this.activeJobs.clear();
+        this.started = false;
+        console.log("Cron scheduler stopped");
+    }
+    addJob(job) {
+        if (!this.opencode || !this.sql)
+            return;
+        const options = {
+            protect: true,
+            name: job.name,
+        };
+        if (job.timezone) {
+            options.timezone = job.timezone;
+        }
+        const cron = new Cron(job.schedule, options, async () => {
+            await this.executeJob(job);
+        });
+        this.activeJobs.set(job.id, { cron, job });
+    }
+    async executeJob(job) {
+        if (!this.sql || !this.opencode)
+            return;
+        const executedAt = new Date();
+        try {
+            const [session] = await this.sql `
+        SELECT session_id FROM sessions WHERE name = ${job.session_name}
+      `;
+            if (!session) {
+                throw new Error(`Session "${job.session_name}" not found`);
+            }
+            const providers = await this.opencode.app.providers();
+            const defaultEntry = Object.entries(providers.default)[0];
+            if (!defaultEntry) {
+                throw new Error("No default model configured");
+            }
+            const injectText = `[Cron Job "${job.name}" — ${executedAt.toISOString()}]\n${job.message}${CRON_INJECTION_BLURB}`;
+            await this.opencode.session.chat(session.session_id, {
+                modelID: defaultEntry[0],
+                providerID: defaultEntry[1],
+                parts: [{ type: "text", text: injectText }],
+            });
+            await this.sql `
+        UPDATE cron_jobs SET last_run = ${executedAt} WHERE id = ${job.id}
+      `;
+            await this.sql `
+        INSERT INTO cron_history (cron_job_id, executed_at, success)
+        VALUES (${job.id}, ${executedAt}, TRUE)
+      `;
+            this.options.onJobExecuted?.(job.id, true);
+            console.log(`Cron job "${job.name}" executed successfully`);
+        }
+        catch (err) {
+            const errorMessage = err instanceof Error ? err.message : String(err);
+            await this.sql `
+        INSERT INTO cron_history (cron_job_id, executed_at, success, error_message)
+        VALUES (${job.id}, ${executedAt}, FALSE, ${errorMessage})
+      `;
+            this.options.onJobExecuted?.(job.id, false, errorMessage);
+            console.error(`Cron job "${job.name}" failed:`, errorMessage);
+        }
+    }
+    addCronJob(job) {
+        if (job.enabled) {
+            this.addJob(job);
+        }
+    }
+    removeCronJob(jobId) {
+        const cronInst = this.activeJobs.get(jobId);
+        if (cronInst) {
+            cronInst.cron.stop();
+            this.activeJobs.delete(jobId);
+        }
+    }
+    enableCronJob(job) {
+        if (!this.activeJobs.has(job.id) && job.enabled) {
+            this.addJob(job);
+        }
+    }
+    disableCronJob(jobId) {
+        this.removeCronJob(jobId);
+    }
+    isTracking(jobId) {
+        return this.activeJobs.has(jobId);
+    }
+}

package/dist/server/index.d.ts

@@ -1,3 +1,4 @@
 import type { Sql } from "../db/index.js";
 import type { OpencodeClient } from "../lib/opencode.js";
-export declare function createApp(sql: Sql, opencode: OpencodeClient, password: string): import("express-serve-static-core").Express;
+import { CronScheduler } from "./cron.js";
+export declare function createApp(sql: Sql, opencode: OpencodeClient, password: string, serverUrl: string, cronScheduler: CronScheduler): import("express-serve-static-core").Express;

package/dist/server/index.js

@@ -10,13 +10,13 @@ function authMiddleware(password) {
         next();
     };
 }
-export function createApp(sql, opencode, password) {
+export function createApp(sql, opencode, password, serverUrl, cronScheduler) {
     const app = express();
     app.use(express.json());
     // Worker routes are unauthenticated — mounted before auth middleware
-    app.use("/", createWorkerRouter(sql));
+    app.use("/", createWorkerRouter(sql, opencode, serverUrl));
     // Everything else requires Bearer auth
     app.use(authMiddleware(password));
-    app.use("/", createRouter(sql, opencode));
+    app.use("/", createRouter(sql, opencode, serverUrl, cronScheduler));
     return app;
 }

package/dist/server/routes.d.ts

@@ -1,5 +1,6 @@
 import { Router } from "express";
 import type { Sql } from "../db/index.js";
 import type { OpencodeClient } from "../lib/opencode.js";
-export declare function createRouter(sql: Sql, opencode: OpencodeClient): Router;
-export declare function createWorkerRouter(sql: Sql): Router;
+import { CronScheduler } from "./cron.js";
+export declare function createRouter(sql: Sql, opencode: OpencodeClient, serverUrl: string, scheduler: CronScheduler): Router;
+export declare function createWorkerRouter(sql: Sql, opencode: OpencodeClient, serverUrl: string): Router;