agent-office 0.0.1 → 0.0.3

package/dist/manage/components/TailMessages.js

@@ -61,12 +61,61 @@ export function TailMessages({ serverUrl, password, onBack, contentHeight }) {
     const messageLines = [];
     for (const msg of messages) {
         for (const part of msg.parts) {
-            // Split multiline text into individual lines for rendering
-            const lines = part.text.split("\n");
-            for (let i = 0; i < lines.length; i++) {
-                messageLines.push({ role: msg.role, text: i === 0 ? lines[i] : `  ${lines[i]}` });
+            if (part.type === "text" && part.text) {
+                // Split multiline text into individual lines for rendering
+                const lines = part.text.split("\n");
+                for (let i = 0; i < lines.length; i++) {
+                    messageLines.push({ role: msg.role, text: i === 0 ? lines[i] : `  ${lines[i]}` });
+                }
+                messageLines.push({ role: msg.role, text: "" }); // blank line between parts
+            }
+            else if (part.type === "tool") {
+                // Tool part has: tool (string), input, output
+                const toolName = typeof part.tool === "string" ? part.tool : String(part.tool ?? "unknown");
+                messageLines.push({ role: msg.role, text: "" }); // Blank line before tool
+                messageLines.push({ role: msg.role, text: `▶ Tool: ${toolName}` });
+                if (part.input !== undefined) {
+                    // Try to pretty-print input if it's an object
+                    let inputStr;
+                    if (typeof part.input === "object" && part.input !== null) {
+                        inputStr = JSON.stringify(part.input, null, 2);
+                    }
+                    else {
+                        inputStr = String(part.input);
+                    }
+                    const lines = inputStr.split("\n");
+                    for (let i = 0; i < Math.min(lines.length, 15); i++) {
+                        messageLines.push({ role: msg.role, text: `  ${lines[i]}` });
+                    }
+                    if (lines.length > 15) {
+                        messageLines.push({ role: msg.role, text: `  [...] (${lines.length - 15} more lines)` });
+                    }
+                }
+                if (part.output !== undefined) {
+                    // Show output type and preview
+                    let outputPreview;
+                    if (typeof part.output === "object" && part.output !== null) {
+                        outputPreview = JSON.stringify(part.output, null, 2).slice(0, 200);
+                    }
+                    else if (typeof part.output === "string") {
+                        outputPreview = part.output.slice(0, 200);
+                    }
+                    else {
+                        outputPreview = String(part.output).slice(0, 200);
+                    }
+                    const outputType = typeof part.output === "object" ? "object" : typeof part.output;
+                    messageLines.push({ role: msg.role, text: `  ${"—".repeat(40)}` });
+                    messageLines.push({ role: msg.role, text: `  Result (${outputType}):` });
+                    const lines = outputPreview.split("\n");
+                    for (let i = 0; i < Math.min(lines.length, 5); i++) {
+                        messageLines.push({ role: msg.role, text: `  ${lines[i]}` });
+                    }
+                    if (lines.length > 5 || outputPreview.length >= 200) {
+                        messageLines.push({ role: msg.role, text: "  [...]" });
+                    }
+                }
+                messageLines.push({ role: msg.role, text: "" }); // Blank line after tool
             }
-            messageLines.push({ role: msg.role, text: "" }); // blank line between parts
         }
     }
     const viewHeight = contentHeight - 3; // header + separator

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

@@ -3,11 +3,22 @@ export interface Session {
     name: string;
     session_id: string;
     agent_code: string;
+    mode: string | null;
+    status: string | null;
     created_at: string;
 }
+export interface AppMode {
+    name: string;
+    description: string;
+    model: string;
+}
 export interface MessagePart {
-    type: "text";
-    text: string;
+    type: "text" | "tool" | "tool-output";
+    text?: string;
+    tool?: string;
+    input?: unknown;
+    output?: unknown;
+    data?: unknown;
 }
 export interface SessionMessage {
     role: "user" | "assistant";
@@ -25,9 +36,28 @@ export interface MailMessage {
 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[]>;
@@ -35,6 +65,10 @@ export declare function useApi(serverUrl: string, password: string): {
         ok: boolean;
         messageID: string;
     }>;
+    revertToStart: (name: string) => Promise<{
+        ok: boolean;
+        messageID: string;
+    }>;
     regenerateCode: (name: string) => Promise<Session>;
     getConfig: () => Promise<Config>;
     setConfig: (key: string, value: string) => Promise<{
@@ -55,6 +89,23 @@ export declare function useApi(serverUrl: string, password: string): {
         }>;
     }>;
     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",
@@ -54,6 +57,9 @@ export function useApi(serverUrl, password) {
     const injectText = useCallback(async (name, text) => {
         return apiFetch(`${base}/sessions/${encodeURIComponent(name)}/inject`, password, { method: "POST", body: JSON.stringify({ text }) });
     }, [base, password]);
+    const revertToStart = useCallback(async (name) => {
+        return apiFetch(`${base}/sessions/${encodeURIComponent(name)}/revert-to-start`, password, { method: "POST" });
+    }, [base, password]);
     const regenerateCode = useCallback(async (name) => {
         return apiFetch(`${base}/sessions/${encodeURIComponent(name)}/regenerate-code`, password, { method: "POST" });
     }, [base, password]);
@@ -78,6 +84,28 @@ export function useApi(serverUrl, 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,
@@ -85,12 +113,20 @@ export function useApi(serverUrl, password) {
         checkHealth,
         getMessages,
         injectText,
+        revertToStart,
         regenerateCode,
         getConfig,
         setConfig,
         getMailMessages,
         sendMailMessage,
         markMessageRead,
+        getModes,
+        listCrons,
+        createCron,
+        deleteCron,
+        enableCron,
+        disableCron,
+        getCronHistory,
     };
 }
 export function useAsyncState() {

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, serverUrl: 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, serverUrl) {
+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, opencode, serverUrl));
     // Everything else requires Bearer auth
     app.use(authMiddleware(password));
-    app.use("/", createRouter(sql, opencode, serverUrl));
+    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, serverUrl: string): 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;