agent-office 0.0.3 → 0.0.6

package/dist/server/routes.js

@@ -73,6 +73,24 @@ function generateWelcomeMessage(name, mode, status, humanName, humanDescription,
         `   agent-office worker cron \\`,
         `     ${token}`,
         ``,
+        ` Store a memory (persistent across sessions)`,
+        `   agent-office worker memory add \\`,
+        `     --content "your memory here" \\`,
+        `     ${token}`,
+        ``,
+        ` Search your memories`,
+        `   agent-office worker memory search \\`,
+        `     --query "your search" \\`,
+        `     ${token}`,
+        ``,
+        ` List all your memories`,
+        `   agent-office worker memory list \\`,
+        `     ${token}`,
+        ``,
+        ` Forget a memory`,
+        `   agent-office worker memory forget \\`,
+        `     ${token} <memory-id>`,
+        ``,
         `════════════════════════════════════════════════════════`,
         ` ⚠  IMPORTANT: YOUR SESSIONS ARE PRIVATE`,
         `════════════════════════════════════════════════════════`,
@@ -109,7 +127,7 @@ function generateWelcomeMessage(name, mode, status, humanName, humanDescription,
         ``,
     ].join("\n");
 }
-export function createRouter(sql, opencode, serverUrl, scheduler) {
+export function createRouter(sql, opencode, serverUrl, scheduler, memoryManager) {
     const router = Router();
     router.get("/health", (_req, res) => {
         res.json({ ok: true });
@@ -366,6 +384,47 @@ export function createRouter(sql, opencode, serverUrl, scheduler) {
             res.status(502).json({ error: "Failed to revert session", detail: String(err) });
         }
     });
+    router.post("/sessions/revert-all", async (_req, res) => {
+        const allSessions = await sql `
+      SELECT id, name, session_id, agent_code, mode, status, created_at FROM sessions
+    `;
+        const providers = await opencode.app.providers();
+        const defaultEntry = Object.entries(providers.default)[0];
+        if (!defaultEntry) {
+            res.status(502).json({ error: "No default model configured in OpenCode" });
+            return;
+        }
+        const results = [];
+        for (const session of allSessions) {
+            try {
+                const messages = await opencode.session.messages(session.session_id);
+                if (messages.length === 0) {
+                    results.push({ name: session.name, ok: false, error: "No messages" });
+                    continue;
+                }
+                const firstMessage = messages[0];
+                if (!firstMessage?.info?.id) {
+                    results.push({ name: session.name, ok: false, error: "Failed to get first message ID" });
+                    continue;
+                }
+                await opencode.session.revert(session.session_id, { messageID: firstMessage.info.id });
+                const clockInToken = `${session.agent_code}@${serverUrl}`;
+                const enrollmentMessage = `You have been enrolled in the agent office.\n\nTo clock in and receive your full briefing, run:\n\n  agent-office worker clock-in ${clockInToken}`;
+                await opencode.session.chat(session.session_id, {
+                    modelID: defaultEntry[0],
+                    providerID: defaultEntry[1],
+                    parts: [{ type: "text", text: enrollmentMessage }],
+                });
+                results.push({ name: session.name, ok: true });
+            }
+            catch (err) {
+                console.error(`POST /sessions/revert-all error for "${session.name}":`, err);
+                results.push({ name: session.name, ok: false, error: String(err) });
+            }
+        }
+        const failed = results.filter((r) => !r.ok);
+        res.json({ ok: failed.length === 0, total: allSessions.length, results });
+    });
     router.delete("/sessions/:name", async (req, res) => {
         const { name } = req.params;
         const rows = await sql `
@@ -500,33 +559,34 @@ export function createRouter(sql, opencode, serverUrl, scheduler) {
             res.status(400).json({ error: "No valid recipients found" });
             return;
         }
+        const providers = await opencode.app.providers();
+        const defaultEntry = Object.entries(providers.default)[0];
         const results = [];
         for (const recipient of validRecipients) {
-            let injected = false;
             const [msgRow] = await sql `
         INSERT INTO messages (from_name, to_name, body)
         VALUES (${trimmedFrom}, ${recipient}, ${trimmedBody})
         RETURNING id, from_name, to_name, body, read, injected, created_at
       `;
-            if (sessionMap.has(recipient)) {
+            const msgId = msgRow.id;
+            let injected = false;
+            if (sessionMap.has(recipient) && defaultEntry) {
                 const sessionId = sessionMap.get(recipient);
-                const msgId = msgRow.id;
-                injected = true;
-                opencode.app.providers().then((providers) => {
-                    const defaultEntry = Object.entries(providers.default)[0];
-                    if (!defaultEntry)
-                        return;
-                    const injectText = `[Message from "${trimmedFrom}"]: ${trimmedBody}${MAIL_INJECTION_BLURB}`;
-                    return opencode.session.chat(sessionId, {
+                const injectText = `[Message from "${trimmedFrom}"]: ${trimmedBody}${MAIL_INJECTION_BLURB}`;
+                try {
+                    await opencode.session.chat(sessionId, {
                         modelID: defaultEntry[0],
                         providerID: defaultEntry[1],
                         parts: [{ type: "text", text: injectText }],
-                    }).then(() => sql `UPDATE messages SET injected = TRUE WHERE id = ${msgId}`);
-                }).catch((err) => {
-                    console.warn(`Warning: could not inject message into session ${recipient}:`, err);
-                });
+                    });
+                    await sql `UPDATE messages SET injected = TRUE WHERE id = ${msgId}`;
+                    injected = true;
+                }
+                catch (err) {
+                    console.warn(`Warning: could not inject message into session "${recipient}":`, err);
+                }
             }
-            results.push({ to: recipient, messageId: msgRow.id, injected });
+            results.push({ to: recipient, messageId: msgId, injected });
         }
         res.status(201).json({ ok: true, results });
     });
@@ -799,9 +859,135 @@ export function createRouter(sql, opencode, serverUrl, scheduler) {
             res.status(500).json({ error: "Internal server error" });
         }
     });
+    // ── Memory Endpoints (authenticated, for manage TUI) ───────────────────────
+    router.get("/sessions/:name/memories", async (req, res) => {
+        const { name } = req.params;
+        const limit = Math.min(parseInt(req.query.limit ?? "50", 10), 200);
+        const rows = await sql `SELECT id FROM sessions WHERE name = ${name}`;
+        if (rows.length === 0) {
+            res.status(404).json({ error: `Session "${name}" not found` });
+            return;
+        }
+        try {
+            const memories = memoryManager.listMemories(name, limit);
+            const stats = memoryManager.getStats(name);
+            res.json({ memories, total: stats.total });
+        }
+        catch (err) {
+            console.error("GET /sessions/:name/memories error:", err);
+            res.status(500).json({ error: "Internal server error" });
+        }
+    });
+    router.post("/sessions/:name/memories", async (req, res) => {
+        const { name } = req.params;
+        const { content, metadata } = req.body;
+        if (!content || typeof content !== "string" || !content.trim()) {
+            res.status(400).json({ error: "content is required" });
+            return;
+        }
+        const rows = await sql `SELECT id FROM sessions WHERE name = ${name}`;
+        if (rows.length === 0) {
+            res.status(404).json({ error: `Session "${name}" not found` });
+            return;
+        }
+        try {
+            const id = await memoryManager.addMemory(name, content.trim(), metadata ?? {});
+            res.status(201).json({ ok: true, id });
+        }
+        catch (err) {
+            console.error("POST /sessions/:name/memories error:", err);
+            res.status(500).json({ error: "Internal server error" });
+        }
+    });
+    router.get("/sessions/:name/memories/:memoryId", async (req, res) => {
+        const { name, memoryId } = req.params;
+        const rows = await sql `SELECT id FROM sessions WHERE name = ${name}`;
+        if (rows.length === 0) {
+            res.status(404).json({ error: `Session "${name}" not found` });
+            return;
+        }
+        try {
+            const memory = memoryManager.getMemory(name, memoryId);
+            if (!memory) {
+                res.status(404).json({ error: "Memory not found" });
+                return;
+            }
+            res.json(memory);
+        }
+        catch (err) {
+            console.error("GET /sessions/:name/memories/:memoryId error:", err);
+            res.status(500).json({ error: "Internal server error" });
+        }
+    });
+    router.put("/sessions/:name/memories/:memoryId", async (req, res) => {
+        const { name, memoryId } = req.params;
+        const { content, metadata } = req.body;
+        if (!content || typeof content !== "string" || !content.trim()) {
+            res.status(400).json({ error: "content is required" });
+            return;
+        }
+        const rows = await sql `SELECT id FROM sessions WHERE name = ${name}`;
+        if (rows.length === 0) {
+            res.status(404).json({ error: `Session "${name}" not found` });
+            return;
+        }
+        try {
+            const updated = await memoryManager.updateMemory(name, memoryId, content.trim(), metadata);
+            if (!updated) {
+                res.status(404).json({ error: "Memory not found" });
+                return;
+            }
+            res.json({ ok: true });
+        }
+        catch (err) {
+            console.error("PUT /sessions/:name/memories/:memoryId error:", err);
+            res.status(500).json({ error: "Internal server error" });
+        }
+    });
+    router.delete("/sessions/:name/memories/:memoryId", async (req, res) => {
+        const { name, memoryId } = req.params;
+        const rows = await sql `SELECT id FROM sessions WHERE name = ${name}`;
+        if (rows.length === 0) {
+            res.status(404).json({ error: `Session "${name}" not found` });
+            return;
+        }
+        try {
+            const deleted = memoryManager.deleteMemory(name, memoryId);
+            if (!deleted) {
+                res.status(404).json({ error: "Memory not found" });
+                return;
+            }
+            res.json({ deleted: true, id: memoryId });
+        }
+        catch (err) {
+            console.error("DELETE /sessions/:name/memories/:memoryId error:", err);
+            res.status(500).json({ error: "Internal server error" });
+        }
+    });
+    router.post("/sessions/:name/memories/search", async (req, res) => {
+        const { name } = req.params;
+        const { query, limit } = req.body;
+        if (!query || typeof query !== "string" || !query.trim()) {
+            res.status(400).json({ error: "query is required" });
+            return;
+        }
+        const rows = await sql `SELECT id FROM sessions WHERE name = ${name}`;
+        if (rows.length === 0) {
+            res.status(404).json({ error: `Session "${name}" not found` });
+            return;
+        }
+        try {
+            const results = await memoryManager.searchMemories(name, query.trim(), Math.min(limit ?? 10, 50));
+            res.json(results);
+        }
+        catch (err) {
+            console.error("POST /sessions/:name/memories/search error:", err);
+            res.status(500).json({ error: "Internal server error" });
+        }
+    });
     return router;
 }
-export function createWorkerRouter(sql, opencode, serverUrl) {
+export function createWorkerRouter(sql, opencode, serverUrl, memoryManager) {
     const router = Router();
     router.get("/worker/clock-in", async (req, res) => {
         const { code } = req.query;
@@ -870,6 +1056,24 @@ export function createWorkerRouter(sql, opencode, serverUrl) {
             `   agent-office worker cron \\`,
             `     ${token}`,
             ``,
+            ` Store a memory (persistent across sessions)`,
+            `   agent-office worker memory add \\`,
+            `     --content "your memory here" \\`,
+            `     ${token}`,
+            ``,
+            ` Search your memories`,
+            `   agent-office worker memory search \\`,
+            `     --query "your search" \\`,
+            `     ${token}`,
+            ``,
+            ` List all your memories`,
+            `   agent-office worker memory list \\`,
+            `     ${token}`,
+            ``,
+            ` Forget a memory`,
+            `   agent-office worker memory forget \\`,
+            `     ${token} <memory-id>`,
+            ``,
             `════════════════════════════════════════════════════════`,
             ` ⚠  IMPORTANT: YOUR SESSIONS ARE PRIVATE`,
             `════════════════════════════════════════════════════════`,
@@ -1020,33 +1224,34 @@ export function createWorkerRouter(sql, opencode, serverUrl) {
             res.status(400).json({ error: "No valid recipients found" });
             return;
         }
+        const providers = await opencode.app.providers();
+        const defaultEntry = Object.entries(providers.default)[0];
         const results = [];
         for (const recipient of validRecipients) {
-            let injected = false;
             const [msgRow] = await sql `
         INSERT INTO messages (from_name, to_name, body)
         VALUES (${session.name}, ${recipient}, ${trimmedBody})
         RETURNING id, from_name, to_name, body, read, injected, created_at
       `;
-            if (sessionMap.has(recipient)) {
+            const msgId = msgRow.id;
+            let injected = false;
+            if (sessionMap.has(recipient) && defaultEntry) {
                 const recipientSessionId = sessionMap.get(recipient);
-                const msgId = msgRow.id;
-                injected = true;
-                opencode.app.providers().then((providers) => {
-                    const defaultEntry = Object.entries(providers.default)[0];
-                    if (!defaultEntry)
-                        return;
-                    const injectText = `[Message from "${session.name}"]: ${trimmedBody}${MAIL_INJECTION_BLURB}`;
-                    return opencode.session.chat(recipientSessionId, {
+                const injectText = `[Message from "${session.name}"]: ${trimmedBody}${MAIL_INJECTION_BLURB}`;
+                try {
+                    await opencode.session.chat(recipientSessionId, {
                         modelID: defaultEntry[0],
                         providerID: defaultEntry[1],
                         parts: [{ type: "text", text: injectText }],
-                    }).then(() => sql `UPDATE messages SET injected = TRUE WHERE id = ${msgId}`);
-                }).catch((err) => {
-                    console.warn(`Warning: could not inject message into session ${recipient}:`, err);
-                });
+                    });
+                    await sql `UPDATE messages SET injected = TRUE WHERE id = ${msgId}`;
+                    injected = true;
+                }
+                catch (err) {
+                    console.warn(`Warning: could not inject message into session "${recipient}":`, err);
+                }
             }
-            results.push({ to: recipient, messageId: msgRow.id, injected });
+            results.push({ to: recipient, messageId: msgId, injected });
         }
         res.status(201).json({ ok: true, results });
     });
@@ -1370,5 +1575,115 @@ export function createWorkerRouter(sql, opencode, serverUrl) {
             res.status(500).json({ error: "Internal server error" });
         }
     });
+    // ── Worker Memory Endpoints (authenticated via agent_code in query) ────────
+    router.post("/worker/memory/add", async (req, res) => {
+        const { code } = req.query;
+        const { content, metadata } = req.body;
+        if (!code || typeof code !== "string") {
+            res.status(400).json({ error: "code query parameter is required" });
+            return;
+        }
+        if (!content || typeof content !== "string" || !content.trim()) {
+            res.status(400).json({ error: "content is required" });
+            return;
+        }
+        const session = await sql `
+      SELECT name FROM sessions WHERE agent_code = ${code}
+    `;
+        if (session.length === 0) {
+            res.status(401).json({ error: "Invalid agent code" });
+            return;
+        }
+        const sessionName = session[0].name;
+        try {
+            const id = await memoryManager.addMemory(sessionName, content.trim(), metadata ?? {});
+            res.status(201).json({ ok: true, id });
+        }
+        catch (err) {
+            console.error("POST /worker/memory/add error:", err);
+            res.status(500).json({ error: "Internal server error" });
+        }
+    });
+    router.post("/worker/memory/search", async (req, res) => {
+        const { code } = req.query;
+        const { query, limit } = req.body;
+        if (!code || typeof code !== "string") {
+            res.status(400).json({ error: "code query parameter is required" });
+            return;
+        }
+        if (!query || typeof query !== "string" || !query.trim()) {
+            res.status(400).json({ error: "query is required" });
+            return;
+        }
+        const session = await sql `
+      SELECT name FROM sessions WHERE agent_code = ${code}
+    `;
+        if (session.length === 0) {
+            res.status(401).json({ error: "Invalid agent code" });
+            return;
+        }
+        const sessionName = session[0].name;
+        try {
+            const results = await memoryManager.searchMemories(sessionName, query.trim(), Math.min(limit ?? 10, 50));
+            res.json(results);
+        }
+        catch (err) {
+            console.error("POST /worker/memory/search error:", err);
+            res.status(500).json({ error: "Internal server error" });
+        }
+    });
+    router.get("/worker/memory/list", async (req, res) => {
+        const { code, limit: limitStr } = req.query;
+        if (!code || typeof code !== "string") {
+            res.status(400).json({ error: "code query parameter is required" });
+            return;
+        }
+        const session = await sql `
+      SELECT name FROM sessions WHERE agent_code = ${code}
+    `;
+        if (session.length === 0) {
+            res.status(401).json({ error: "Invalid agent code" });
+            return;
+        }
+        const sessionName = session[0].name;
+        const limit = Math.min(parseInt(limitStr ?? "50", 10), 200);
+        try {
+            const memories = memoryManager.listMemories(sessionName, limit);
+            const stats = memoryManager.getStats(sessionName);
+            res.json({ memories, total: stats.total });
+        }
+        catch (err) {
+            console.error("GET /worker/memory/list error:", err);
+            res.status(500).json({ error: "Internal server error" });
+        }
+    });
+    router.delete("/worker/memory/:memoryId", async (req, res) => {
+        const { code } = req.query;
+        const { memoryId } = req.params;
+        if (!code || typeof code !== "string") {
+            res.status(400).json({ error: "code query parameter is required" });
+            return;
+        }
+        const session = await sql `
+      SELECT name FROM sessions WHERE agent_code = ${code}
+    `;
+        if (session.length === 0) {
+            res.status(401).json({ error: "Invalid agent code" });
+            return;
+        }
+        const sessionName = session[0].name;
+        try {
+            const deleted = memoryManager.deleteMemory(sessionName, memoryId);
+            if (!deleted) {
+                res.status(404).json({ error: "Memory not found" });
+                return;
+            }
+            res.json({ deleted: true, id: memoryId });
+        }
+        catch (err) {
+            console.error("DELETE /worker/memory/:memoryId error:", err);
+            res.status(500).json({ error: "Internal server error" });
+        }
+    });
     return router;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-office",
-  "version": "0.0.3",
+  "version": "0.0.6",
   "description": "Manage OpenCode sessions with named aliases",
   "type": "module",
   "license": "MIT",
@@ -23,6 +23,7 @@
     "dev:serve": "tsx --watch src/cli.ts serve",
     "dev:manage": "tsx src/cli.ts manage",
     "dev:worker": "tsx src/cli.ts worker",
+    "dev:communicator": "tsx src/cli.ts communicator web",
     "build": "tsc",
     "clean": "rm -rf dist",
     "prepublishOnly": "npm run clean && npm run build"
@@ -38,11 +39,13 @@
     "croner": "^10.0.1",
     "dotenv": "^16.0.0",
     "express": "^4.18.0",
+    "fastmemory": "^0.1.5",
     "ink": "^5.0.0",
     "postgres": "^3.4.0",
     "react": "^18.0.0"
   },
   "devDependencies": {
+    "@types/better-sqlite3": "^7.6.13",
     "@types/express": "^4.17.0",
     "@types/node": "^20.0.0",
     "@types/react": "^18.0.0",