agent-office 0.3.1 → 0.4.0

package/dist/commands/worker.js

@@ -96,7 +96,8 @@ export async function listCrons(token) {
     console.log(JSON.stringify(crons, null, 2));
 }
 export async function createCron(token, options) {
-    const cron = await postWorker(token, "/worker/crons", options);
+    const finalMessage = `Action: ${options.message}\n\nWho to respond to when done: ${options.respondTo}`;
+    const cron = await postWorker(token, "/worker/crons", { name: options.name, schedule: options.schedule, message: finalMessage, timezone: options.timezone });
     console.log(JSON.stringify(cron, null, 2));
 }
 export async function deleteCron(token, cronId) {
@@ -138,66 +139,3 @@ export async function cronHistory(token, cronId) {
     const history = await fetchWorker(token, `/worker/crons/${cronId}/history`);
     console.log(JSON.stringify(history, null, 2));
 }
-// ── Memory Commands ──────────────────────────────────────────────────────────
-export async function memoryAdd(token, content) {
-    const result = await postWorker(token, "/worker/memory/add", { content });
-    console.log(JSON.stringify(result, null, 2));
-}
-export async function memorySearch(token, query, limit) {
-    const result = await postWorker(token, "/worker/memory/search", { query, limit });
-    console.log(JSON.stringify(result, null, 2));
-}
-export async function memoryList(token, limit) {
-    const { agentCode, serverUrl } = parseToken(token);
-    const url = `${serverUrl}/worker/memory/list?code=${encodeURIComponent(agentCode)}&limit=${limit}`;
-    let res;
-    try {
-        res = await fetch(url);
-    }
-    catch (err) {
-        console.error(`Error: could not reach ${serverUrl}`);
-        console.error(err instanceof Error ? err.message : String(err));
-        process.exit(1);
-    }
-    let body;
-    try {
-        body = await res.json();
-    }
-    catch {
-        console.error(`Error: invalid response from server`);
-        process.exit(1);
-    }
-    if (!res.ok) {
-        const msg = body.error ?? `HTTP ${res.status}`;
-        console.error(`Error: ${msg}`);
-        process.exit(1);
-    }
-    console.log(JSON.stringify(body, null, 2));
-}
-export async function memoryForget(token, memoryId) {
-    const { agentCode, serverUrl } = parseToken(token);
-    const url = `${serverUrl}/worker/memory/${encodeURIComponent(memoryId)}?code=${encodeURIComponent(agentCode)}`;
-    let res;
-    try {
-        res = await fetch(url, { method: "DELETE" });
-    }
-    catch (err) {
-        console.error(`Error: could not reach ${serverUrl}`);
-        console.error(err instanceof Error ? err.message : String(err));
-        process.exit(1);
-    }
-    let body;
-    try {
-        body = await res.json();
-    }
-    catch {
-        console.error(`Error: invalid response from server`);
-        process.exit(1);
-    }
-    if (!res.ok) {
-        const msg = body.error ?? `HTTP ${res.status}`;
-        console.error(`Error: ${msg}`);
-        process.exit(1);
-    }
-    console.log(JSON.stringify(body, null, 2));
-}

package/dist/db/index.d.ts

@@ -24,6 +24,7 @@ export interface MessageRow {
     body: string;
     read: boolean;
     injected: boolean;
+    notified?: boolean;
     created_at: Date;
 }
 export interface CronJobRow {

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

@@ -19,11 +19,17 @@ export declare class AgentOfficePostgresqlStorage extends AgentOfficeStorageBase
     getAllConfig(): Promise<ConfigRow[]>;
     getConfig(key: string): Promise<string | null>;
     setConfig(key: string, value: string): Promise<void>;
-    listMessagesForRecipient(name: string, unreadOnly: boolean): Promise<MessageRow[]>;
+    listMessagesForRecipient(name: string, filters?: {
+        unread?: boolean;
+        olderThanHours?: number;
+        notified?: boolean;
+    }): Promise<MessageRow[]>;
     listMessagesFromSender(name: string): Promise<MessageRow[]>;
+    countUnreadBySender(recipientName: string): Promise<Map<string, number>>;
     createMessageImpl(from: string, to: string, body: string): Promise<MessageRow>;
     markMessageAsRead(id: number): Promise<MessageRow | null>;
     markMessageAsInjected(id: number): Promise<void>;
+    markMessagesAsNotified(ids: number[]): Promise<void>;
     listCronJobs(): Promise<CronJobRow[]>;
     listCronJobsForSession(sessionName: string): Promise<CronJobRow[]>;
     getCronJobById(id: number): Promise<CronJobRow | null>;

package/dist/db/postgresql-storage.js

@@ -107,21 +107,19 @@ export class AgentOfficePostgresqlStorage extends AgentOfficeStorageBase {
     `;
     }
     // Messages
-    async listMessagesForRecipient(name, unreadOnly) {
-        if (unreadOnly) {
-            return this.sql `
-        SELECT id, from_name, to_name, body, read, injected, created_at
-        FROM messages
-        WHERE to_name = ${name} AND read = FALSE
-        ORDER BY created_at DESC
-      `;
+    async listMessagesForRecipient(name, filters) {
+        const whereClauses = ["to_name = $1"];
+        const params = [name];
+        if (filters?.unread)
+            whereClauses.push("read = FALSE");
+        if (filters?.notified === false)
+            whereClauses.push("notified = FALSE");
+        if (filters?.olderThanHours !== undefined) {
+            whereClauses.push(`created_at < NOW() - INTERVAL '${filters.olderThanHours} hours'`);
         }
-        return this.sql `
-      SELECT id, from_name, to_name, body, read, injected, created_at
-      FROM messages
-      WHERE to_name = ${name}
-      ORDER BY created_at DESC
-    `;
+        const whereSQL = whereClauses.join(" AND ");
+        const rows = await this.sql.unsafe(`SELECT id, from_name, to_name, body, read, injected, created_at, notified FROM messages WHERE ${whereSQL} ORDER BY created_at DESC`, params);
+        return rows;
     }
     async listMessagesFromSender(name) {
         return this.sql `
@@ -131,6 +129,19 @@ export class AgentOfficePostgresqlStorage extends AgentOfficeStorageBase {
       ORDER BY created_at DESC
     `;
     }
+    async countUnreadBySender(recipientName) {
+        const rows = await this.sql `
+      SELECT from_name, COUNT(*) as count
+      FROM messages
+      WHERE to_name = ${recipientName} AND read = FALSE
+      GROUP BY from_name
+    `;
+        const result = new Map();
+        for (const row of rows) {
+            result.set(row.from_name, Number(row.count));
+        }
+        return result;
+    }
     async createMessageImpl(from, to, body) {
         const [row] = await this.sql `
       INSERT INTO messages (from_name, to_name, body)
@@ -149,6 +160,11 @@ export class AgentOfficePostgresqlStorage extends AgentOfficeStorageBase {
     async markMessageAsInjected(id) {
         await this.sql `UPDATE messages SET injected = TRUE WHERE id = ${id}`;
     }
+    async markMessagesAsNotified(ids) {
+        if (ids.length === 0)
+            return;
+        await this.sql `UPDATE messages SET notified = TRUE WHERE id = ANY(${ids})`;
+    }
     // Cron Jobs
     async listCronJobs() {
         return this.sql `
@@ -330,6 +346,13 @@ export class AgentOfficePostgresqlStorage extends AgentOfficeStorageBase {
                 name: "rename_mode_to_agent",
                 sql: `
           ALTER TABLE sessions RENAME COLUMN mode TO agent;
+        `,
+            },
+            {
+                version: 9,
+                name: "add_notified_to_messages",
+                sql: `
+          ALTER TABLE messages ADD COLUMN IF NOT EXISTS notified BOOLEAN NOT NULL DEFAULT FALSE;
         `,
             },
         ];

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

@@ -20,11 +20,17 @@ export declare class AgentOfficeSqliteStorage extends AgentOfficeStorageBase {
     getAllConfig(): Promise<ConfigRow[]>;
     getConfig(key: string): Promise<string | null>;
     setConfig(key: string, value: string): Promise<void>;
-    listMessagesForRecipient(name: string, unreadOnly: boolean): Promise<MessageRow[]>;
+    listMessagesForRecipient(name: string, filters?: {
+        unread?: boolean;
+        olderThanHours?: number;
+        notified?: boolean;
+    }): Promise<MessageRow[]>;
     listMessagesFromSender(name: string): Promise<MessageRow[]>;
+    countUnreadBySender(recipientName: string): Promise<Map<string, number>>;
     createMessageImpl(from: string, to: string, body: string): Promise<MessageRow>;
     markMessageAsRead(id: number): Promise<MessageRow | null>;
     markMessageAsInjected(id: number): Promise<void>;
+    markMessagesAsNotified(ids: number[]): Promise<void>;
     listCronJobs(): Promise<CronJobRow[]>;
     listCronJobsForSession(sessionName: string): Promise<CronJobRow[]>;
     getCronJobById(id: number): Promise<CronJobRow | null>;

package/dist/db/sqlite-storage.js

@@ -142,21 +142,32 @@ export class AgentOfficeSqliteStorage extends AgentOfficeStorageBase {
         stmt.run(key, value);
     }
     // Messages
-    async listMessagesForRecipient(name, unreadOnly) {
-        const sql = unreadOnly
-            ? `SELECT id, from_name, to_name, body, read, injected, created_at
-         FROM messages
-         WHERE to_name = ? AND read = FALSE
-         ORDER BY created_at DESC`
-            : `SELECT id, from_name, to_name, body, read, injected, created_at
-         FROM messages
-         WHERE to_name = ?
-         ORDER BY created_at DESC`;
+    async listMessagesForRecipient(name, filters) {
+        let whereClauses = [`to_name = ?`];
+        let params = [name];
+        if (filters?.unread) {
+            whereClauses.push(`read = 0`);
+        }
+        if (filters?.notified === false) {
+            whereClauses.push(`notified != 1`);
+        }
+        if (filters?.olderThanHours !== undefined) {
+            const hours = filters.olderThanHours;
+            whereClauses.push(`created_at < datetime('now', '-${hours} hours')`);
+        }
+        const where = whereClauses.join(' AND ');
+        const sql = `SELECT id, from_name, to_name, body, read, injected, created_at, notified
+                 FROM messages
+                 WHERE ${where}
+                 ORDER BY created_at DESC`;
         const stmt = this.db.prepare(sql);
-        const rows = stmt.all(name);
+        const rows = stmt.all(...params);
         return rows.map(row => ({
             ...row,
-            created_at: new Date(row.created_at + 'Z'), // Treat SQLite datetime as UTC
+            read: !!row.read,
+            injected: !!row.injected,
+            notified: !!row.notified,
+            created_at: new Date(row.created_at + 'Z'),
         }));
     }
     async listMessagesFromSender(name) {
@@ -172,6 +183,20 @@ export class AgentOfficeSqliteStorage extends AgentOfficeStorageBase {
             created_at: new Date(row.created_at + 'Z'), // Treat SQLite datetime as UTC
         }));
     }
+    async countUnreadBySender(recipientName) {
+        const stmt = this.db.prepare(`
+      SELECT from_name, COUNT(*) as count
+      FROM messages
+      WHERE to_name = ? AND read = FALSE
+      GROUP BY from_name
+    `);
+        const rows = stmt.all(recipientName);
+        const result = new Map();
+        for (const row of rows) {
+            result.set(row.from_name, row.count);
+        }
+        return result;
+    }
     async createMessageImpl(from, to, body) {
         const stmt = this.db.prepare(`
       INSERT INTO messages (from_name, to_name, body)
@@ -201,6 +226,13 @@ export class AgentOfficeSqliteStorage extends AgentOfficeStorageBase {
         const stmt = this.db.prepare(`UPDATE messages SET injected = TRUE WHERE id = ?`);
         stmt.run(id);
     }
+    async markMessagesAsNotified(ids) {
+        if (ids.length === 0)
+            return;
+        const placeholders = ids.map(() => '?').join(',');
+        const stmt = this.db.prepare(`UPDATE messages SET notified = 1 WHERE id IN (${placeholders})`);
+        stmt.run(...ids);
+    }
     // Cron Jobs
     async listCronJobs() {
         const stmt = this.db.prepare(`
@@ -433,6 +465,13 @@ export class AgentOfficeSqliteStorage extends AgentOfficeStorageBase {
           ALTER TABLE sessions_new RENAME TO sessions;
           CREATE INDEX IF NOT EXISTS idx_sessions_name ON sessions(name);
           CREATE UNIQUE INDEX IF NOT EXISTS idx_sessions_agent_code ON sessions(agent_code);
+        `,
+            },
+            {
+                version: 9,
+                name: "add_notified_to_messages",
+                sql: `
+          ALTER TABLE messages ADD COLUMN notified INTEGER NOT NULL DEFAULT 0;
         `,
             },
         ];

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

@@ -21,10 +21,16 @@ export declare abstract class AgentOfficeStorageBase implements AgentOfficeStora
     abstract getAllConfig(): Promise<ConfigRow[]>;
     abstract getConfig(key: string): Promise<string | null>;
     abstract setConfig(key: string, value: string): Promise<void>;
-    abstract listMessagesForRecipient(name: string, unreadOnly: boolean): Promise<MessageRow[]>;
+    abstract listMessagesForRecipient(name: string, filters?: {
+        unread?: boolean;
+        olderThanHours?: number;
+        notified?: boolean;
+    }): Promise<MessageRow[]>;
     abstract listMessagesFromSender(name: string): Promise<MessageRow[]>;
+    abstract countUnreadBySender(recipientName: string): Promise<Map<string, number>>;
     abstract markMessageAsRead(id: number): Promise<MessageRow | null>;
     abstract markMessageAsInjected(id: number): Promise<void>;
+    abstract markMessagesAsNotified(ids: number[]): Promise<void>;
     abstract listCronJobs(): Promise<CronJobRow[]>;
     abstract listCronJobsForSession(sessionName: string): Promise<CronJobRow[]>;
     abstract getCronJobById(id: number): Promise<CronJobRow | null>;

package/dist/db/storage-base.js

@@ -18,7 +18,7 @@ export class AgentOfficeStorageBase {
         }
         // For each session, find all messages sent to them and track the latest per sender
         for (const session of sessions) {
-            const messages = await this.listMessagesForRecipient(session.name, false);
+            const messages = await this.listMessagesForRecipient(session.name);
             const senderMap = this.coworkerMailState.get(session.name);
             for (const message of messages) {
                 const existingDate = senderMap.get(message.from_name);

package/dist/db/storage.d.ts

@@ -30,11 +30,17 @@ export interface AgentOfficeStorage {
     getAllConfig(): Promise<ConfigRow[]>;
     getConfig(key: string): Promise<string | null>;
     setConfig(key: string, value: string): Promise<void>;
-    listMessagesForRecipient(name: string, unreadOnly: boolean): Promise<MessageRow[]>;
+    listMessagesForRecipient(name: string, filters?: {
+        unread?: boolean;
+        olderThanHours?: number;
+        notified?: boolean;
+    }): Promise<MessageRow[]>;
     listMessagesFromSender(name: string): Promise<MessageRow[]>;
+    countUnreadBySender(recipientName: string): Promise<Map<string, number>>;
     createMessage(from: string, to: string, body: string): Promise<MessageRow>;
     markMessageAsRead(id: number): Promise<MessageRow | null>;
     markMessageAsInjected(id: number): Promise<void>;
+    markMessagesAsNotified(ids: number[]): Promise<void>;
     listCronJobs(): Promise<CronJobRow[]>;
     listCronJobsForSession(sessionName: string): Promise<CronJobRow[]>;
     getCronJobById(id: number): Promise<CronJobRow | null>;

package/dist/lib/notifier.d.ts

@@ -0,0 +1,18 @@
+export interface NotifyOptions {
+    from: string;
+    to: string;
+    subject: string;
+    text: string;
+}
+/**
+ * Abstract notification interface — swap out the implementation
+ * (email, SMS, webhook, etc.) without changing the daemon logic.
+ */
+export interface AgentOfficeNotifier {
+    send(opts: NotifyOptions): Promise<void>;
+}
+export declare class ResendNotifier implements AgentOfficeNotifier {
+    private resend;
+    constructor(apiKey: string);
+    send(opts: NotifyOptions): Promise<void>;
+}

package/dist/lib/notifier.js

@@ -0,0 +1,15 @@
+import { Resend } from "resend";
+export class ResendNotifier {
+    resend;
+    constructor(apiKey) {
+        this.resend = new Resend(apiKey);
+    }
+    async send(opts) {
+        await this.resend.emails.send({
+            from: opts.from,
+            to: [opts.to],
+            subject: opts.subject,
+            text: opts.text,
+        });
+    }
+}