agent-office 0.0.2 → 0.0.4

package/dist/server/routes.js

@@ -4,13 +4,130 @@ const MAIL_INJECTION_BLURB = [
     ``,
     `---`,
     `You have a new message. Please review the injected message above and respond accordingly.`,
-    `Respond using markdown. Your markdown front-matter can contain a property "choices" which`,
-    `is an array of choices for the message sender to choose from. These choices are optional`,
-    `and shouldn't alter your authentic personality in your responses.`,
-    `IMPORTANT: in order for the sender to see your response, you must send them a message back`,
-    `using the \`agent-office worker send-message\` tool. Also, don't go on for too long if things seem repetitive.`,
+    `IMPORTANT: When reading or responding, note that dollar signs ($) and other special`,
+    `characters may be interpreted as markdown. The sender may have included them but they`,
+    `could appear differently in your session view. Interpret context accordingly.`,
+    ``,
+    `When responding to the sender:`,
+    `- Use the \`agent-office worker send-message\` tool so they can see your reply`,
+    `- Avoid excessive length - keep responses concise`,
+    `- Use markdown front-matter with a "choices" array if offering options`,
+    ``,
+    `Tip: For currency or prices, use code blocks. Example: put numbers in single or`,
+    `double quotes to preserve formatting characters like dollar signs.`,
 ].join("\n");
-export function createRouter(sql, opencode, serverUrl, scheduler) {
+function generateWelcomeMessage(name, mode, status, humanName, humanDescription, token) {
+    return [
+        `╔══════════════════════════════════════════════════════╗`,
+        `║              WELCOME TO THE AGENT OFFICE             ║`,
+        `╚══════════════════════════════════════════════════════╝`,
+        ``,
+        `You are now clocked in.`,
+        `  Name:           ${name}`,
+        ...(mode ? [`  Mode:           ${mode}`] : []),
+        ...(status ? [`  Status:         ${status}`] : []),
+        `  Human manager:  ${humanName} — the human who created your`,
+        `                  session, assigns your work, and is your`,
+        `                  primary point of contact for questions,`,
+        `                  updates, and decisions.`,
+        ...(humanDescription ? [
+            `                  "${humanDescription}"`,
+        ] : []),
+        ``,
+        `The agent-office CLI is your PRIMARY means of communicating`,
+        `with your human manager (${humanName}) and your coworkers.`,
+        `Use it to send and receive messages, and to discover who`,
+        `else is working.`,
+        ``,
+        `════════════════════════════════════════════════════════`,
+        ` AVAILABLE COMMANDS`,
+        `════════════════════════════════════════════════════════`,
+        ``,
+        ` List your coworkers`,
+        `   agent-office worker list-coworkers \\`,
+        `     ${token}`,
+        ``,
+        ` Set your public status (visible to coworkers and manager)`,
+        `   agent-office worker set-status \\`,
+        `     --status "your status here" \\`,
+        `     ${token}`,
+        ``,
+        ` Clear your public status`,
+        `   agent-office worker set-status \\`,
+        `     --clear \\`,
+        `     ${token}`,
+        ``,
+        ` Send a message to your manager or a coworker`,
+        `   agent-office worker send-message \\`,
+        `     --name <recipient-name> \\`,
+        `     --body "Your message here" \\`,
+        `     ${token}`,
+        ``,
+        ` Send a message to multiple recipients at once`,
+        `   agent-office worker send-message \\`,
+        `     --name alice --name bob \\`,
+        `     --body "Your message here" \\`,
+        `     ${token}`,
+        ``,
+        ` Manage scheduled tasks (optional)`,
+        `   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`,
+        `════════════════════════════════════════════════════════`,
+        ``,
+        ` Nobody — not ${humanName}, not your coworkers — can see`,
+        ` anything you think, reason, or write inside this session.`,
+        ` Your work is completely private until you explicitly send`,
+        ` a message using the send-message command.`,
+        ``,
+        ` This means:`,
+        `   • You must send a message to report progress or ask`,
+        `     for help. Silence looks like inaction.`,
+        `   • Finishing a task without messaging ${humanName}`,
+        `     means they will never know it is done.`,
+        `   • If you are blocked or uncertain, send a message —`,
+        `     nobody will know otherwise.`,
+        ``,
+        `════════════════════════════════════════════════════════`,
+        ` TIPS`,
+        `════════════════════════════════════════════════════════`,
+        ``,
+        ` - Run list-coworkers to discover who is available and`,
+        `   what their names are before sending messages.`,
+        ` - Messages you send are delivered directly into the`,
+        `   recipient's active session — they will see them`,
+        `   immediately.`,
+        ` - Your human manager is ${humanName}. They can send you`,
+        `   messages at any time and those will appear here in`,
+        `   your session just like this one. You can reach them`,
+        `   by sending a message to --name ${humanName}.`,
+        ` - Optional: Set up recurring scheduled tasks with cron`,
+        `   jobs. Run 'agent-office worker cron list ${token}' to`,
+        `   get started.`,
+        ``,
+    ].join("\n");
+}
+export function createRouter(sql, opencode, serverUrl, scheduler, memoryManager) {
     const router = Router();
     router.get("/health", (_req, res) => {
         res.json({ ok: true });
@@ -36,7 +153,7 @@ export function createRouter(sql, opencode, serverUrl, scheduler) {
     router.get("/sessions", async (_req, res) => {
         try {
             const rows = await sql `
-        SELECT id, name, session_id, agent_code, mode, created_at
+        SELECT id, name, session_id, agent_code, mode, status, created_at
         FROM sessions
         ORDER BY created_at DESC
       `;
@@ -95,12 +212,11 @@ export function createRouter(sql, opencode, serverUrl, scheduler) {
             const defaultEntry = Object.entries(providers.default)[0];
             if (defaultEntry) {
                 const clockInToken = `${row.agent_code}@${serverUrl}`;
-                const modeNote = trimmedMode ? `\n  Mode:  ${trimmedMode}` : "";
-                const firstMessage = `You have been enrolled in the agent office.${modeNote}\n\nTo clock in and receive your full briefing, run:\n\n  agent-office worker clock-in ${clockInToken}`;
+                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(opencodeSessionId, {
                     modelID: defaultEntry[0],
                     providerID: defaultEntry[1],
-                    parts: [{ type: "text", text: firstMessage }],
+                    parts: [{ type: "text", text: enrollmentMessage }],
                     ...(trimmedMode ? { mode: trimmedMode } : {}),
                 });
             }
@@ -150,9 +266,26 @@ export function createRouter(sql, opencode, serverUrl, scheduler) {
                 .slice(-limit)
                 .map((m) => ({
                 role: m.info.role,
-                parts: m.parts
-                    .filter((p) => p.type === "text")
-                    .map((p) => ({ type: "text", text: p.text })),
+                parts: m.parts.map((p) => {
+                    const part = p;
+                    if (part.type === "text") {
+                        return { type: "text", text: part.text ?? "" };
+                    }
+                    else if (part.type === "tool") {
+                        // Extract tool name, input, and output from the tool state
+                        const state = part.state;
+                        return {
+                            type: "tool",
+                            tool: part.tool,
+                            input: state?.input,
+                            output: state?.output,
+                            data: part,
+                        };
+                    }
+                    else {
+                        return { type: part.type, data: part };
+                    }
+                }),
             }))
                 .filter((m) => m.parts.length > 0);
             res.json(result);
@@ -209,6 +342,48 @@ export function createRouter(sql, opencode, serverUrl, scheduler) {
             res.status(502).json({ error: "Failed to inject message into OpenCode session", detail: String(err) });
         }
     });
+    router.post("/sessions/:name/revert-to-start", async (req, res) => {
+        const { name } = req.params;
+        const rows = await sql `
+      SELECT id, name, session_id, agent_code, mode, status, created_at FROM sessions WHERE name = ${name}
+    `;
+        if (rows.length === 0) {
+            res.status(404).json({ error: `Session "${name}" not found` });
+            return;
+        }
+        const session = rows[0];
+        try {
+            const messages = await opencode.session.messages(session.session_id);
+            if (messages.length === 0) {
+                res.status(400).json({ error: "Session has no messages to revert to" });
+                return;
+            }
+            const firstMessage = messages[0];
+            if (!firstMessage || !firstMessage.info || !firstMessage.info.id) {
+                res.status(500).json({ error: "Failed to get first message ID" });
+                return;
+            }
+            await opencode.session.revert(session.session_id, { messageID: firstMessage.info.id });
+            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 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 }],
+            });
+            res.json({ ok: true, messageID: firstMessage.info.id });
+        }
+        catch (err) {
+            console.error("POST /sessions/:name/revert-to-start error:", err);
+            res.status(502).json({ error: "Failed to revert session", detail: String(err) });
+        }
+    });
     router.delete("/sessions/:name", async (req, res) => {
         const { name } = req.params;
         const rows = await sql `
@@ -642,9 +817,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;
@@ -713,6 +1014,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`,
             `════════════════════════════════════════════════════════`,
@@ -784,6 +1103,42 @@ export function createWorkerRouter(sql, opencode, serverUrl) {
             res.status(500).json({ error: "Internal server error" });
         }
     });
+    router.post("/worker/set-status", async (req, res) => {
+        const { code } = req.query;
+        const { status } = req.body;
+        if (!code || typeof code !== "string") {
+            res.status(400).json({ error: "code query parameter is required" });
+            return;
+        }
+        const trimmedStatus = status === null ? null : (status === undefined ? null : status.trim());
+        if (trimmedStatus !== null && trimmedStatus.length > 140) {
+            res.status(400).json({ error: "status must be at most 140 characters" });
+            return;
+        }
+        const rows = await sql `
+      SELECT id, name, session_id, agent_code, mode, status, created_at
+      FROM sessions
+      WHERE agent_code = ${code}
+    `;
+        if (rows.length === 0) {
+            res.status(401).json({ error: "Invalid agent code" });
+            return;
+        }
+        const session = rows[0];
+        try {
+            await sql `
+        UPDATE sessions
+        SET status = ${trimmedStatus}
+        WHERE agent_code = ${code}
+      `;
+        }
+        catch (err) {
+            console.error("POST /worker/set-status error:", err);
+            res.status(500).json({ error: "Internal server error" });
+            return;
+        }
+        res.json({ ok: true, name: session.name, status: trimmedStatus });
+    });
     router.post("/worker/send-message", async (req, res) => {
         const { code } = req.query;
         const { to, body } = req.body;
@@ -1177,5 +1532,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.2",
+  "version": "0.0.4",
   "description": "Manage OpenCode sessions with named aliases",
   "type": "module",
   "license": "MIT",
@@ -33,15 +33,18 @@
   "dependencies": {
     "@inkjs/ui": "^2.0.0",
     "@opencode-ai/sdk": "^0.1.0-alpha.21",
+    "agent-office": "^0.0.2",
     "commander": "^12.0.0",
     "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",