agent-office 0.3.1 → 0.4.0

package/dist/commands/communicator.js

@@ -1,11 +1,11 @@
 import express from "express";
 // ── API helpers ───────────────────────────────────────────────────────────────
-async function apiFetch(agentUrl, secret, path, init = {}) {
+async function apiFetch(agentUrl, password, path, init = {}) {
     const res = await fetch(`${agentUrl}${path}`, {
         ...init,
         headers: {
             "Content-Type": "application/json",
-            "Authorization": `Bearer ${secret}`,
+            "Authorization": `Bearer ${password}`,
             ...(init.headers ?? {}),
         },
     });
@@ -15,19 +15,22 @@ async function apiFetch(agentUrl, secret, path, init = {}) {
     }
     return res.json();
 }
-async function getHumanName(agentUrl, secret) {
-    const cfg = await apiFetch(agentUrl, secret, "/config");
+async function getHumanName(agentUrl, password) {
+    const cfg = await apiFetch(agentUrl, password, "/config");
     return cfg.human_name ?? "Human";
 }
-async function fetchCoworkerStatus(agentUrl, secret, coworker) {
-    const sessions = await apiFetch(agentUrl, secret, "/sessions");
+async function fetchSessions(agentUrl, password) {
+    return apiFetch(agentUrl, password, "/sessions");
+}
+async function fetchCoworkerStatus(agentUrl, password, coworker) {
+    const sessions = await fetchSessions(agentUrl, password);
     const session = sessions.find((s) => s.name === coworker);
     return session?.status ?? null;
 }
-async function fetchMessages(agentUrl, secret, humanName, coworker) {
+async function fetchMessages(agentUrl, password, humanName, coworker) {
     const [sent, received] = await Promise.all([
-        apiFetch(agentUrl, secret, `/messages/${encodeURIComponent(humanName)}?sent=true`),
-        apiFetch(agentUrl, secret, `/messages/${encodeURIComponent(humanName)}`),
+        apiFetch(agentUrl, password, `/messages/${encodeURIComponent(humanName)}?sent=true`),
+        apiFetch(agentUrl, password, `/messages/${encodeURIComponent(humanName)}`),
     ]);
     // sent: from humanName → coworker
     const sentToCoworker = sent.filter((m) => m.to_name === coworker);
@@ -37,8 +40,8 @@ async function fetchMessages(agentUrl, secret, humanName, coworker) {
     all.sort((a, b) => new Date(a.created_at).getTime() - new Date(b.created_at).getTime());
     return all;
 }
-async function markRead(agentUrl, secret, id) {
-    await apiFetch(agentUrl, secret, `/messages/${id}/read`, { method: "POST" });
+async function markRead(agentUrl, password, id) {
+    await apiFetch(agentUrl, password, `/messages/${id}/read`, { method: "POST" });
 }
 // ── HTML helpers ──────────────────────────────────────────────────────────────
 function escapeHtml(str) {
@@ -83,14 +86,31 @@ function renderMessages(msgs, humanName) {
     return `<div id="messages-inner" data-last-id="${lastId}">${inner}</div>`;
 }
 // ── Full page ─────────────────────────────────────────────────────────────────
-function renderPage(coworker, msgs, humanName) {
+function renderDropdown(coworker, coworkers) {
+    const selected = coworker ?? "";
+    const dropdownOptions = coworkers.filter(c => !c.isHuman);
+    const totalUnread = dropdownOptions.reduce((sum, c) => sum + (c.unreadMessages ?? 0), 0);
+    const unreadDot = totalUnread > 0 ? '<span class="unread-badge"></span>' : '';
+    const coworkerOptions = dropdownOptions.map(c => {
+        const unreadBadge = c.unreadMessages && c.unreadMessages > 0 ? ` (${c.unreadMessages})` : '';
+        return `<option value="${escapeHtml(c.name)}" ${c.name === selected ? 'selected' : ''}>${escapeHtml(c.name)}${unreadBadge}</option>`;
+    }).join('');
+    return `<select id="coworker-select" class="coworker-select" onchange="switchCoworker(this.value)">
+        <option value="">Select coworker…</option>
+        ${coworkerOptions}
+      </select>
+      ${unreadDot}`;
+}
+function renderPage(coworker, coworkers, msgs, humanName) {
     const msgsHtml = renderMessages(msgs, humanName);
+    const selected = coworker ?? "";
+    const dropdownHtml = renderDropdown(coworker, coworkers);
     return `<!DOCTYPE html>
 <html lang="en">
 <head>
   <meta charset="UTF-8">
   <meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1">
-  <title>${escapeHtml(coworker)} — agent-office</title>
+  <title>${selected ? escapeHtml(selected) + ' — ' : ''}agent-office</title>
   <script src="https://unpkg.com/htmx.org@2.0.4/dist/htmx.min.js"></script>
   <script src="https://cdn.jsdelivr.net/npm/marked@11.1.1/marked.min.js"></script>
   <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/github-markdown-css@5.5.1/github-markdown-light.min.css" media="(prefers-color-scheme: light)">
@@ -162,6 +182,29 @@ function renderPage(coworker, msgs, humanName) {
     }
 
     .header-info { flex: 1; min-width: 0; }
+    .select-wrapper { display: inline-flex; align-items: center; position: relative; }
+    .coworker-select {
+      font-weight: 600;
+      font-size: 15px;
+      background: transparent;
+      border: none;
+      color: var(--text);
+      cursor: pointer;
+      padding: 0;
+      margin: 0;
+      outline: none;
+      max-width: 180px;
+    }
+    .coworker-select:focus { color: var(--accent); }
+    .coworker-select option { background: var(--surface); color: var(--text); }
+    .unread-badge {
+      width: 8px;
+      height: 8px;
+      background: #ff4444;
+      border-radius: 50%;
+      margin-left: 6px;
+      flex-shrink: 0;
+    }
     .header-name {
       font-weight: 600;
       font-size: 15px;
@@ -418,22 +461,28 @@ function renderPage(coworker, msgs, humanName) {
 
   <!-- Header -->
   <div class="header">
-    <div class="avatar">${escapeHtml(coworker.charAt(0).toUpperCase())}</div>
+    <div class="avatar">${selected ? escapeHtml(selected.charAt(0).toUpperCase()) : '?'}</div>
     <div class="header-info">
-      <div class="header-name">${escapeHtml(coworker)}</div>
+      <div class="select-wrapper" id="dropdown-wrapper"
+           hx-get="/dropdown?coworker=${encodeURIComponent(selected)}"
+           hx-trigger="load, every 5s"
+           hx-swap="innerHTML">
+        ${dropdownHtml}
+      </div>
       <div class="header-sub"
            id="coworker-status"
-           hx-get="/status"
+           hx-get="/status?coworker=${encodeURIComponent(selected)}"
            hx-trigger="load, every 5s"
            hx-swap="innerHTML"></div>
     </div>
     <button class="reset-btn"
-            hx-post="/reset"
+            hx-post="/reset?coworker=${encodeURIComponent(selected)}"
             hx-target="#reset-status"
             hx-swap="innerHTML"
-            hx-confirm="Reset ${escapeHtml(coworker)}'s session? This will revert them to their first message and re-inject the enrollment prompt."
+            hx-confirm="Reset session? This will revert them to their first message and re-inject the enrollment prompt."
             hx-on::after-request="showResetStatus()"
-            title="Reset session">
+            title="Reset session"
+            ${!selected ? 'disabled' : ''}>
       ↺ Reset
     </button>
     <div class="refresh-indicator" id="refresh-dot"
@@ -449,7 +498,7 @@ function renderPage(coworker, msgs, humanName) {
   <!-- Messages -->
   <div class="messages-outer" id="messages-outer">
     <div id="messages"
-         hx-get="/messages"
+         hx-get="/messages?coworker=${encodeURIComponent(selected)}"
          hx-trigger="load, every 5s"
          hx-swap="innerHTML">
       ${msgsHtml}
@@ -466,11 +515,12 @@ function renderPage(coworker, msgs, humanName) {
           hx-on::after-request="handleSent(event)"
           hx-on::before-request="this.querySelector('.send-btn').classList.add('sending')"
           hx-encoding="application/x-www-form-urlencoded">
+      <input type="hidden" name="coworker" value="${escapeHtml(selected)}">
       <textarea
         class="input-textarea"
         name="body"
         id="msg-input"
-        placeholder="Message ${escapeHtml(coworker)}…"
+        placeholder="${selected ? 'Message ' + escapeHtml(selected) + '…' : 'Select a coworker to message…'}"
         rows="1"
         autocomplete="off"
         autocorrect="on"
@@ -554,6 +604,14 @@ function renderPage(coworker, msgs, humanName) {
   // Initial scroll
   scrollToBottom()
 
+  // Switch to a different coworker
+  function switchCoworker(name) {
+    if (!name) return
+    const url = new URL(window.location.href)
+    url.searchParams.set('coworker', name)
+    window.location.href = url.toString()
+  }
+
   // Flash the reset status toast then fade it out
   function showResetStatus() {
     const el = document.getElementById('reset-status')
@@ -569,8 +627,9 @@ function renderPage(coworker, msgs, humanName) {
     document.querySelectorAll('.markdown-body[data-markdown-b64]').forEach(el => {
       const b64 = el.getAttribute('data-markdown-b64')
       if (b64 && !el.hasAttribute('data-rendered')) {
-        // Decode base64 to get original text with preserved newlines
-        const text = atob(b64)
+        // Decode base64 to get original text with preserved newlines and UTF-8 chars
+        const binary = atob(b64)
+        const text = new TextDecoder().decode(Uint8Array.from(binary, c => c.charCodeAt(0)))
         el.innerHTML = marked.parse(text)
         el.setAttribute('data-rendered', 'true')
       }
@@ -589,8 +648,8 @@ function renderPage(coworker, msgs, humanName) {
 </html>`;
 }
 // ── Express app ───────────────────────────────────────────────────────────────
-export async function appCoworkerChatWeb(coworker, options) {
-    const { url: agentUrl, secret, host, port: portStr } = options;
+export async function appCoworkerChatWeb(options) {
+    const { url: agentUrl, password, host, port: portStr } = options;
     const port = parseInt(portStr, 10);
     if (isNaN(port) || port < 1 || port > 65535) {
         console.error(`Error: invalid port "${portStr}"`);
@@ -606,22 +665,76 @@ export async function appCoworkerChatWeb(coworker, options) {
     // Resolve human name once at startup
     let humanName = "Human";
     try {
-        humanName = await getHumanName(agentUrl, secret);
+        humanName = await getHumanName(agentUrl, password);
     }
     catch (err) {
         console.error(`Warning: could not fetch human name from ${agentUrl}: ${err instanceof Error ? err.message : String(err)}`);
-        console.error("Check that agent-office serve is running and --secret is correct.");
+        console.error("Check that agent-office serve is running and --password is correct.");
     }
-    console.log(`Communicator: chatting as "${humanName}" with "${coworker}"`);
+    console.log(`Communicator: chatting as "${humanName}"`);
     const app = express();
     app.use(express.urlencoded({ extended: false }));
     app.use(express.json());
+    // ── GET /coworkers — list of coworkers (HTMX) ───────────────────────────────
+    app.get("/coworkers", async (_req, res) => {
+        res.setHeader("Content-Type", "application/json");
+        try {
+            const response = await fetch(`${agentUrl}/coworkers`, {
+                headers: { "Authorization": `Bearer ${password}` },
+            });
+            if (!response.ok) {
+                res.json([{ name: humanName, status: null, isHuman: true, unreadMessages: 0 }]);
+                return;
+            }
+            const coworkers = await response.json();
+            res.json(coworkers);
+        }
+        catch {
+            res.json([{ name: humanName, status: null, isHuman: true, unreadMessages: 0 }]);
+        }
+    });
+    // ── GET /dropdown — dropdown fragment for HTMX polling ────────────────────
+    app.get("/dropdown", async (req, res) => {
+        const coworker = req.query.coworker;
+        res.setHeader("Content-Type", "text/html; charset=utf-8");
+        try {
+            const response = await fetch(`${agentUrl}/coworkers`, {
+                headers: { "Authorization": `Bearer ${password}` },
+            });
+            if (!response.ok) {
+                res.send(renderDropdown(coworker ?? null, [{ name: humanName, status: null, isHuman: true, unreadMessages: 0 }]));
+                return;
+            }
+            const coworkers = await response.json();
+            res.send(renderDropdown(coworker ?? null, coworkers));
+        }
+        catch {
+            res.send(renderDropdown(coworker ?? null, [{ name: humanName, status: null, isHuman: true, unreadMessages: 0 }]));
+        }
+    });
     // ── GET / — full page ────────────────────────────────────────────────────
-    app.get("/", async (_req, res) => {
+    app.get("/", async (req, res) => {
         try {
-            const msgs = await fetchMessages(agentUrl, secret, humanName, coworker);
+            // Fetch coworkers with unread counts from main server
+            const response = await fetch(`${agentUrl}/coworkers`, {
+                headers: { "Authorization": `Bearer ${password}` },
+            });
+            let coworkers;
+            if (response.ok) {
+                coworkers = await response.json();
+            }
+            else {
+                coworkers = [{ name: humanName, status: null, isHuman: true, unreadMessages: 0 }];
+            }
+            const nonHumans = coworkers.filter(c => !c.isHuman);
+            let coworker = req.query.coworker;
+            // Default to first non-human coworker if none specified
+            if (!coworker && nonHumans.length > 0) {
+                coworker = nonHumans[0].name;
+            }
+            const msgs = coworker ? await fetchMessages(agentUrl, password, humanName, coworker) : [];
             res.setHeader("Content-Type", "text/html; charset=utf-8");
-            res.send(renderPage(coworker, msgs, humanName));
+            res.send(renderPage(coworker ?? null, coworkers, msgs, humanName));
         }
         catch (err) {
             const msg = err instanceof Error ? err.message : String(err);
@@ -629,12 +742,18 @@ export async function appCoworkerChatWeb(coworker, options) {
         }
     });
     // ── GET /messages — HTMX fragment (polled every 5s) ──────────────────────
-    app.get("/messages", async (_req, res) => {
+    app.get("/messages", async (req, res) => {
+        const coworker = req.query.coworker;
+        if (!coworker) {
+            res.setHeader("Content-Type", "text/html; charset=utf-8");
+            res.send(`<div class="empty-state">Select a coworker to view messages.</div>`);
+            return;
+        }
         try {
-            const msgs = await fetchMessages(agentUrl, secret, humanName, coworker);
+            const msgs = await fetchMessages(agentUrl, password, humanName, coworker);
             // Mark any unread received messages as read
             const unread = msgs.filter((m) => m.from_name === coworker && !m.read);
-            await Promise.allSettled(unread.map((m) => markRead(agentUrl, secret, m.id)));
+            await Promise.allSettled(unread.map((m) => markRead(agentUrl, password, m.id)));
             res.setHeader("Content-Type", "text/html; charset=utf-8");
             res.send(renderMessages(msgs, humanName));
         }
@@ -646,14 +765,20 @@ export async function appCoworkerChatWeb(coworker, options) {
     });
     // ── POST /send — HTMX form submit ────────────────────────────────────────
     app.post("/send", async (req, res) => {
-        const body = req.body.body?.trim();
+        const { body: msgBody, coworker } = req.body;
+        const body = msgBody?.trim();
         if (!body) {
             res.setHeader("Content-Type", "text/html; charset=utf-8");
             res.send(`<span class="send-err">Message cannot be empty.</span>`);
             return;
         }
+        if (!coworker) {
+            res.setHeader("Content-Type", "text/html; charset=utf-8");
+            res.send(`<span class="send-err">No coworker selected.</span>`);
+            return;
+        }
         try {
-            await apiFetch(agentUrl, secret, "/messages", {
+            await apiFetch(agentUrl, password, "/messages", {
                 method: "POST",
                 body: JSON.stringify({ from: humanName, to: [coworker], body }),
             });
@@ -667,10 +792,15 @@ export async function appCoworkerChatWeb(coworker, options) {
         }
     });
     // ── GET /status — coworker status fragment (polled every 5s) ────────────
-    app.get("/status", async (_req, res) => {
+    app.get("/status", async (req, res) => {
+        const coworker = req.query.coworker;
         res.setHeader("Content-Type", "text/html; charset=utf-8");
+        if (!coworker) {
+            res.send(`<span style="color:var(--text-dim)">—</span>`);
+            return;
+        }
         try {
-            const status = await fetchCoworkerStatus(agentUrl, secret, coworker);
+            const status = await fetchCoworkerStatus(agentUrl, password, coworker);
             res.send(status ? escapeHtml(status) : `<span style="color:var(--text-dim)">—</span>`);
         }
         catch {
@@ -678,10 +808,15 @@ export async function appCoworkerChatWeb(coworker, options) {
         }
     });
     // ── POST /reset — revert the coworker's session to first message ─────────
-    app.post("/reset", async (_req, res) => {
+    app.post("/reset", async (req, res) => {
+        const coworker = req.query.coworker;
         res.setHeader("Content-Type", "text/html; charset=utf-8");
+        if (!coworker) {
+            res.send(`<span style="color:var(--red)">✗ No coworker selected.</span>`);
+            return;
+        }
         try {
-            await apiFetch(agentUrl, secret, `/sessions/${encodeURIComponent(coworker)}/revert-to-start`, {
+            await apiFetch(agentUrl, password, `/sessions/${encodeURIComponent(coworker)}/revert-to-start`, {
                 method: "POST",
             });
             res.send(`<span style="color:var(--green)">✓ ${escapeHtml(coworker)} reset and restarted.</span>`);

package/dist/commands/notifier.d.ts

@@ -0,0 +1,11 @@
+import { type AgentOfficeNotifier } from "../lib/notifier.js";
+type Options = {
+    agentOfficeUrl?: string;
+    password?: string;
+    toEmail?: string;
+    resendApiKey?: string;
+    domain?: string;
+    waitMinutes?: string;
+};
+export declare function notifier(options: Options, customNotifier?: AgentOfficeNotifier): Promise<void>;
+export {};

package/dist/commands/notifier.js

@@ -0,0 +1,100 @@
+import { Cron } from "croner";
+import { ResendNotifier } from "../lib/notifier.js";
+export async function notifier(options, customNotifier) {
+    const toEmail = options.toEmail;
+    if (!toEmail) {
+        console.error("Error: --to-email or TO_EMAIL env required");
+        process.exit(1);
+    }
+    const domain = options.domain;
+    if (!domain) {
+        console.error("Error: --domain or EMAIL_DOMAIN env required");
+        process.exit(1);
+    }
+    const agentOfficeUrl = options.agentOfficeUrl ?? "http://127.0.0.1:7654";
+    const password = options.password;
+    if (!password) {
+        console.error("Error: --password or AGENT_OFFICE_PASSWORD env required");
+        process.exit(1);
+    }
+    const waitMinutes = parseInt(options.waitMinutes ?? "15", 10);
+    const waitHours = waitMinutes / 60;
+    let notify;
+    if (customNotifier) {
+        notify = customNotifier;
+    }
+    else {
+        const resendApiKey = options.resendApiKey;
+        if (!resendApiKey) {
+            console.error("Error: --resend-api-key or RESEND_API_KEY env required");
+            process.exit(1);
+        }
+        notify = new ResendNotifier(resendApiKey);
+    }
+    const authHeaders = {
+        Authorization: `Bearer ${password}`,
+        "Content-Type": "application/json",
+    };
+    const check = async () => {
+        try {
+            // Fetch messages old enough to notify about
+            const resp = await fetch(`${agentOfficeUrl}/human/unread-old?hours=${waitHours}`, {
+                headers: authHeaders,
+            });
+            if (!resp.ok) {
+                console.error(`GET /human/unread-old failed: ${resp.status}`);
+                return;
+            }
+            const qualifying = (await resp.json());
+            if (qualifying.length === 0) {
+                // Check if there are any unread messages at all (just not old enough yet)
+                const allResp = await fetch(`${agentOfficeUrl}/human/unread-old?hours=0`, {
+                    headers: authHeaders,
+                });
+                if (allResp.ok) {
+                    const allUnread = (await allResp.json());
+                    if (allUnread.length > 0) {
+                        console.log(`${allUnread.length} unread message(s) exist but haven't been waiting >${waitMinutes}m yet — skipping notification`);
+                    }
+                    else {
+                        console.log("No unread messages — nothing to notify");
+                    }
+                }
+                return;
+            }
+            const senders = [...new Set(qualifying.map((m) => m.from_name))];
+            for (const sender of senders) {
+                const fromAddress = `${sender} <${sender.replace(/\s+/g, "+")}@${domain}>`;
+                await notify.send({
+                    from: fromAddress,
+                    to: toEmail,
+                    subject: "Agent Office: Message Waiting",
+                    text: "There is a message waiting for you at Agent Office.",
+                });
+                console.log(`Sent out notification for waiting mail | from: ${fromAddress} | to: ${toEmail}`);
+            }
+            const ids = qualifying.map((m) => m.id);
+            const markResp = await fetch(`${agentOfficeUrl}/human/mark-notified`, {
+                method: "POST",
+                headers: authHeaders,
+                body: JSON.stringify({ ids }),
+            });
+            if (!markResp.ok) {
+                console.error(`POST /human/mark-notified failed: ${markResp.status}`);
+            }
+        }
+        catch (e) {
+            console.error("Notifier cron error:", e);
+        }
+    };
+    const cron = new Cron("0 * * * *", check);
+    console.log(`Agent Office notifier started. Notifying for messages unread >${waitMinutes}m. Checking ${agentOfficeUrl} every hour. ^C to stop.`);
+    await check();
+    const shutdown = async () => {
+        console.log("\nShutting down...");
+        cron.stop();
+        process.exit(0);
+    };
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+}

package/dist/commands/screensaver.d.ts

@@ -1,6 +1,6 @@
 interface ScreensaverOptions {
     url: string;
-    secret: string;
+    password: string;
     host: string;
     port: string;
 }

package/dist/commands/screensaver.js

@@ -1,6 +1,6 @@
 import express from "express";
 export async function appScreensaver(options) {
-    const { url: agentUrl, secret, host, port: portStr } = options;
+    const { url: agentUrl, password, host, port: portStr } = options;
     const port = parseInt(portStr, 10);
     if (isNaN(port) || port < 1 || port > 65535) {
         console.error(`Error: invalid port "${portStr}"`);
@@ -16,6 +16,26 @@ export async function appScreensaver(options) {
     console.log(`Screensaver: visualizing mail activity from ${agentUrl}/watch`);
     const app = express();
     app.use(express.json());
+    // ── GET /coworkers — proxies coworker list from agent-office ───────────────
+    app.get("/coworkers", async (_req, res) => {
+        res.setHeader("Content-Type", "application/json");
+        try {
+            const response = await fetch(`${agentUrl}/coworkers`, {
+                headers: {
+                    "Authorization": `Bearer ${password}`,
+                },
+            });
+            if (!response.ok) {
+                res.json([]);
+                return;
+            }
+            const data = await response.json();
+            res.json(data);
+        }
+        catch {
+            res.json([]);
+        }
+    });
     // ── GET / — Three.js ring visualization ─────────────────────────────────────
     app.get("/", (_req, res) => {
         res.setHeader("Content-Type", "text/html; charset=utf-8");
@@ -40,7 +60,7 @@ export async function appScreensaver(options) {
             // Connect to the agent-office /watch endpoint
             const response = await fetch(`${agentUrl}/watch`, {
                 headers: {
-                    "Authorization": `Bearer ${secret}`,
+                    "Authorization": `Bearer ${password}`,
                 },
                 signal: abortController.signal,
             });
@@ -150,6 +170,7 @@ function renderScreensaverPage() {
     let agentNodes = new Map()   // name -> { mesh, label, angle }
     let arrowObjects = []        // { from, to, mesh, arrowHead, createdAt, opacity }
     let watchState = {}          // latest state from SSE
+    let coworkersSet = new Set() // valid coworker names from /coworkers endpoint
 
     // Track all messages we've seen: key = "from->to", value = lastSent ISO string
     let messageEdges = new Map() // "from->to" -> { lastSent: Date }
@@ -1092,11 +1113,15 @@ function renderScreensaverPage() {
       watchState = state
       const nameSet = new Set()
 
-      // Collect all agent names and message edges
+      // Collect all agent names and message edges (only for valid coworkers)
       for (const agentName in state) {
+        // Only include if this is a known coworker
+        if (!coworkersSet.has(agentName)) continue
         nameSet.add(agentName)
         const senders = state[agentName] || {}
         for (const senderName in senders) {
+          // Only include sender if they're also a known coworker
+          if (!coworkersSet.has(senderName)) continue
           nameSet.add(senderName)
           const edgeKey = senderName + '->' + agentName
           const lastSent = new Date(senders[senderName].lastSent)
@@ -1135,6 +1160,25 @@ function renderScreensaverPage() {
       updateArrows()
     }
 
+    // ── Fetch coworkers list on startup ──────────────────────────────────────
+    async function fetchCoworkers() {
+      try {
+        const response = await fetch('/coworkers')
+        const coworkers = await response.json()
+        coworkersSet = new Set(coworkers.map(c => c.name))
+        console.log('Loaded coworkers:', Array.from(coworkersSet))
+        // Re-process watch state if we already have data
+        if (Object.keys(watchState).length > 0) {
+          processWatchState(watchState)
+        }
+      } catch (err) {
+        console.error('Failed to fetch coworkers:', err)
+      }
+    }
+
+    // Fetch coworkers immediately
+    fetchCoworkers()
+
     // ── SSE connection ─────────────────────────────────────────────────────
     const es = new EventSource('/watch-stream')
 

package/dist/commands/serve.d.ts

@@ -3,10 +3,8 @@ interface ServeOptions {
     sqlite?: string;
     host: string;
     port: string;
-    memoryPath: string;
     password?: string;
     opencodeUrl: string;
-    simpleMemory?: boolean;
 }
 export declare function serve(options: ServeOptions): Promise<void>;
 export {};

package/dist/commands/serve.js

@@ -3,7 +3,6 @@ import { runMigrations } from "../db/migrate.js";
 import { OpenCodeCodingServer } from "../lib/opencode-coding-server.js";
 import { createApp } from "../server/index.js";
 import { CronScheduler } from "../server/cron.js";
-import { AgentOfficeFastMemory, AgentOfficeSimpleMemory } from "../server/memory.js";
 export async function serve(options) {
     const password = options.password;
     if (!password) {
@@ -44,33 +43,10 @@ export async function serve(options) {
     const agenticCodingServer = new OpenCodeCodingServer(options.opencodeUrl);
     console.log(`Connecting to OpenCode server at ${options.opencodeUrl}...`);
     const serverUrl = `http://${options.host}:${port}`;
-    // Create memory manager
-    let memoryManager;
-    if (options.simpleMemory) {
-        console.log("Using simple SQLite+BM25 memory backend.");
-        memoryManager = new AgentOfficeSimpleMemory(options.memoryPath);
-        await memoryManager.warmup();
-    }
-    else {
-        memoryManager = new AgentOfficeFastMemory(options.memoryPath);
-        console.log("Warming up embedding model...");
-        try {
-            await memoryManager.warmup();
-            console.log("Embedding model ready.");
-        }
-        catch (err) {
-            console.error("Embedding model failed to load:", err);
-            console.error("Try deleting the model cache and restarting:");
-            console.error(`  rm -rf ${options.memoryPath}/.model-cache`);
-            memoryManager.closeAll();
-            await storage.close();
-            process.exit(1);
-        }
-    }
     // Create cron scheduler
     const cronScheduler = new CronScheduler();
     // Create Express app
-    const app = createApp(storage, agenticCodingServer, password, serverUrl, cronScheduler, memoryManager);
+    const app = createApp(storage, agenticCodingServer, password, serverUrl, cronScheduler);
     // Start cron scheduler
     await cronScheduler.start(storage, agenticCodingServer, serverUrl);
     // Start server
@@ -82,7 +58,6 @@ export async function serve(options) {
         console.log("\nShutting down...");
         server.close(async () => {
             cronScheduler.stop();
-            memoryManager.closeAll();
             await storage.close();
             console.log("Goodbye.");
             process.exit(0);

package/dist/commands/worker.d.ts

@@ -6,13 +6,10 @@ export declare function createCron(token: string, options: {
     name: string;
     schedule: string;
     message: string;
+    respondTo: string;
     timezone?: string;
 }): Promise<void>;
 export declare function deleteCron(token: string, cronId: number): Promise<void>;
 export declare function enableCron(token: string, cronId: number): Promise<void>;
 export declare function disableCron(token: string, cronId: number): Promise<void>;
 export declare function cronHistory(token: string, cronId: number): Promise<void>;
-export declare function memoryAdd(token: string, content: string): Promise<void>;
-export declare function memorySearch(token: string, query: string, limit: number): Promise<void>;
-export declare function memoryList(token: string, limit: number): Promise<void>;
-export declare function memoryForget(token: string, memoryId: string): Promise<void>;