agent-office 0.0.3 → 0.0.6

package/dist/cli.js

@@ -13,6 +13,7 @@ program
     .option("--opencode-url <url>", "OpenCode server URL", process.env.OPENCODE_URL ?? "http://localhost:4096")
     .option("--host <host>", "Host to bind to", "127.0.0.1")
     .option("--port <port>", "Port to serve on", "7654")
+    .option("--memory-path <path>", "Directory for memory storage (default: ./.memory)", "./.memory")
     .option("--password <password>", "REQUIRED. API password", process.env.AGENT_OFFICE_PASSWORD)
     .action(async (options) => {
     const { serve } = await import("./commands/serve.js");
@@ -27,6 +28,21 @@ program
     const { manage } = await import("./commands/manage.js");
     await manage(url, options);
 });
+const communicatorCmd = program
+    .command("communicator")
+    .description("[HUMAN ONLY] Communicator interfaces for talking with coworkers");
+communicatorCmd
+    .command("web")
+    .description("[HUMAN ONLY] Launch a web chat interface for a single coworker")
+    .argument("<coworker>", "Name of the coworker to chat with (e.g. 'Howard Roark')")
+    .requiredOption("--url <url>", "URL of the agent-office serve endpoint (e.g. http://localhost:7654)")
+    .requiredOption("--secret <secret>", "API password for the agent-office server")
+    .option("--host <host>", "Host to bind the communicator web server to", "127.0.0.1")
+    .option("--port <port>", "Port to run the communicator web server on", "7655")
+    .action(async (coworker, options) => {
+    const { communicatorWeb } = await import("./commands/communicator.js");
+    await communicatorWeb(coworker, options);
+});
 const workerCmd = program
     .command("worker")
     .description("Worker agent commands");
@@ -157,4 +173,47 @@ cronCmd
     const { cronHistory } = await import("./commands/worker.js");
     await cronHistory(token, cronId);
 });
+// ── Worker Memory Commands (nested) ──────────────────────────────────────────
+const memoryCmd = workerCmd
+    .command("memory")
+    .description("Manage your persistent memories");
+memoryCmd
+    .command("add")
+    .argument("<token>", "Agent token in the format <agent_code>@<server-url>")
+    .description("Add a new memory")
+    .requiredOption("--content <content>", "Memory content to store")
+    .action(async (token, options) => {
+    const { memoryAdd } = await import("./commands/worker.js");
+    await memoryAdd(token, options.content);
+});
+memoryCmd
+    .command("search")
+    .argument("<token>", "Agent token in the format <agent_code>@<server-url>")
+    .description("Search memories using hybrid search (keyword + semantic)")
+    .requiredOption("--query <query>", "Search query")
+    .option("--limit <limit>", "Maximum results (default 10)", "10")
+    .action(async (token, options) => {
+    const limit = parseInt(options.limit ?? "10", 10);
+    const { memorySearch } = await import("./commands/worker.js");
+    await memorySearch(token, options.query, limit);
+});
+memoryCmd
+    .command("list")
+    .argument("<token>", "Agent token in the format <agent_code>@<server-url>")
+    .description("List all stored memories")
+    .option("--limit <limit>", "Maximum memories to list (default 50)", "50")
+    .action(async (token, options) => {
+    const limit = parseInt(options.limit ?? "50", 10);
+    const { memoryList } = await import("./commands/worker.js");
+    await memoryList(token, limit);
+});
+memoryCmd
+    .command("forget")
+    .argument("<token>", "Agent token in the format <agent_code>@<server-url>")
+    .argument("<memoryId>", "ID of the memory to forget")
+    .description("Delete a memory by ID")
+    .action(async (token, memoryId) => {
+    const { memoryForget } = await import("./commands/worker.js");
+    await memoryForget(token, memoryId);
+});
 program.parse();

package/dist/commands/communicator.d.ts

@@ -0,0 +1,8 @@
+interface CommunicatorOptions {
+    url: string;
+    secret: string;
+    host: string;
+    port: string;
+}
+export declare function communicatorWeb(coworker: string, options: CommunicatorOptions): Promise<void>;
+export {};

package/dist/commands/communicator.js

@@ -0,0 +1,595 @@
+import express from "express";
+// ── API helpers ───────────────────────────────────────────────────────────────
+async function apiFetch(agentUrl, secret, path, init = {}) {
+    const res = await fetch(`${agentUrl}${path}`, {
+        ...init,
+        headers: {
+            "Content-Type": "application/json",
+            "Authorization": `Bearer ${secret}`,
+            ...(init.headers ?? {}),
+        },
+    });
+    if (!res.ok) {
+        const body = await res.json().catch(() => ({}));
+        throw new Error(body.error ?? `HTTP ${res.status}`);
+    }
+    return res.json();
+}
+async function getHumanName(agentUrl, secret) {
+    const cfg = await apiFetch(agentUrl, secret, "/config");
+    return cfg.human_name ?? "Human";
+}
+async function fetchCoworkerStatus(agentUrl, secret, coworker) {
+    const sessions = await apiFetch(agentUrl, secret, "/sessions");
+    const session = sessions.find((s) => s.name === coworker);
+    return session?.status ?? null;
+}
+async function fetchMessages(agentUrl, secret, humanName, coworker) {
+    const [sent, received] = await Promise.all([
+        apiFetch(agentUrl, secret, `/messages/${encodeURIComponent(humanName)}?sent=true`),
+        apiFetch(agentUrl, secret, `/messages/${encodeURIComponent(humanName)}`),
+    ]);
+    // sent: from humanName → coworker
+    const sentToCoworker = sent.filter((m) => m.to_name === coworker);
+    // received: to humanName, from coworker
+    const receivedFromCoworker = received.filter((m) => m.from_name === coworker);
+    const all = [...sentToCoworker, ...receivedFromCoworker];
+    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" });
+}
+// ── HTML helpers ──────────────────────────────────────────────────────────────
+function escapeHtml(str) {
+    return str
+        .replace(/&/g, "&")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/"/g, "&quot;")
+        .replace(/'/g, "&#39;");
+}
+function formatTime(iso) {
+    return new Date(iso).toLocaleString(undefined, {
+        month: "short", day: "numeric",
+        hour: "2-digit", minute: "2-digit",
+    });
+}
+function renderMessage(msg, humanName, spacingClass) {
+    const isMine = msg.from_name === humanName;
+    const bubbleClass = isMine ? "bubble bubble-mine" : "bubble bubble-theirs";
+    const wrapClass = `msg-wrap ${isMine ? "msg-wrap-mine" : "msg-wrap-theirs"} ${spacingClass}`;
+    const bodyHtml = escapeHtml(msg.body).replace(/\n/g, "<br>");
+    const unreadDot = !isMine && !msg.read ? `<span class="unread-dot"></span>` : "";
+    return `<div class="${wrapClass}" data-id="${msg.id}">
+  <div class="${bubbleClass}">
+    <div class="bubble-body">${bodyHtml}</div>
+    <div class="bubble-time">${unreadDot}${formatTime(msg.created_at)}</div>
+  </div>
+</div>`;
+}
+function renderMessages(msgs, humanName) {
+    const lastId = msgs.length > 0 ? msgs[msgs.length - 1].id : 0;
+    const inner = msgs.length === 0
+        ? `<div class="empty-state">No messages yet. Say hello!</div>`
+        : msgs.map((m, i) => {
+            const prev = msgs[i - 1];
+            // larger gap when the sender changes, tight gap within a run
+            const spacingClass = (!prev || prev.from_name !== m.from_name) ? "gap-sender-change" : "gap-same-sender";
+            return renderMessage(m, humanName, spacingClass);
+        }).join("\n");
+    // data-last-id lets the client detect whether new messages actually arrived
+    return `<div id="messages-inner" data-last-id="${lastId}">${inner}</div>`;
+}
+// ── Full page ─────────────────────────────────────────────────────────────────
+function renderPage(coworker, msgs, humanName) {
+    const msgsHtml = renderMessages(msgs, humanName);
+    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>
+  <script src="https://unpkg.com/htmx.org@2.0.4/dist/htmx.min.js"></script>
+  <style>
+    *, *::before, *::after { box-sizing: border-box; margin: 0; padding: 0; }
+
+    :root {
+      --bg: #0f1117;
+      --surface: #1a1d27;
+      --surface2: #22263a;
+      --border: #2e3248;
+      --accent: #6c8eff;
+      --accent-dim: #3d52a0;
+      --text: #e2e8f0;
+      --text-dim: #8892a4;
+      --mine-bg: #2a3a6e;
+      --mine-border: #4a6fa5;
+      --theirs-bg: #1e2235;
+      --theirs-border: #2e3a55;
+      --red: #ff6b6b;
+      --green: #6bffb8;
+      --radius: 18px;
+      --radius-sm: 8px;
+      --header-h: 56px;
+      --input-h: 64px;
+      font-size: 16px;
+    }
+
+    html, body {
+      height: 100%;
+      background: var(--bg);
+      color: var(--text);
+      font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", system-ui, sans-serif;
+      overflow: hidden;
+    }
+
+    /* ── Layout ── */
+    .app {
+      display: flex;
+      flex-direction: column;
+      height: 100dvh;
+    }
+
+    /* ── Header ── */
+    .header {
+      flex-shrink: 0;
+      height: var(--header-h);
+      background: var(--surface);
+      border-bottom: 1px solid var(--border);
+      display: flex;
+      align-items: center;
+      padding: 0 16px;
+      gap: 12px;
+    }
+
+    .avatar {
+      width: 36px;
+      height: 36px;
+      border-radius: 50%;
+      background: var(--accent-dim);
+      color: var(--accent);
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      font-weight: 700;
+      font-size: 15px;
+      flex-shrink: 0;
+    }
+
+    .header-info { flex: 1; min-width: 0; }
+    .header-name {
+      font-weight: 600;
+      font-size: 15px;
+      white-space: nowrap;
+      overflow: hidden;
+      text-overflow: ellipsis;
+    }
+    .header-sub {
+      font-size: 11px;
+      color: var(--text-dim);
+    }
+
+    .refresh-indicator {
+      width: 8px; height: 8px;
+      border-radius: 50%;
+      background: var(--text-dim);
+      flex-shrink: 0;
+      transition: background 0.3s;
+    }
+    .refresh-indicator.active { background: var(--green); }
+
+    /* ── Reset button ── */
+    .reset-btn {
+      background: none;
+      border: 1px solid var(--border);
+      border-radius: var(--radius-sm);
+      color: var(--text-dim);
+      cursor: pointer;
+      font-size: 12px;
+      padding: 5px 10px;
+      flex-shrink: 0;
+      transition: border-color 0.15s, color 0.15s;
+      white-space: nowrap;
+    }
+    .reset-btn:hover { border-color: var(--red); color: var(--red); }
+    .reset-btn:active { opacity: 0.7; }
+    .reset-btn.htmx-request { opacity: 0.5; pointer-events: none; }
+
+    #reset-status {
+      position: fixed;
+      bottom: 80px;
+      left: 50%;
+      transform: translateX(-50%);
+      background: var(--surface2);
+      border: 1px solid var(--border);
+      border-radius: var(--radius-sm);
+      padding: 8px 16px;
+      font-size: 13px;
+      pointer-events: none;
+      opacity: 0;
+      transition: opacity 0.2s;
+      white-space: nowrap;
+      z-index: 10;
+    }
+    #reset-status.visible { opacity: 1; }
+
+    /* ── Message list ── */
+    .messages-outer {
+      flex: 1;
+      overflow-y: auto;
+      overscroll-behavior: contain;
+      padding: 12px 0 4px;
+      scroll-behavior: smooth;
+    }
+
+    /* Subtle scrollbar */
+    .messages-outer::-webkit-scrollbar { width: 4px; }
+    .messages-outer::-webkit-scrollbar-track { background: transparent; }
+    .messages-outer::-webkit-scrollbar-thumb { background: var(--border); border-radius: 4px; }
+
+    #messages { padding: 0 12px; display: flex; flex-direction: column; }
+    .gap-same-sender   { margin-top: 3px; }
+    .gap-sender-change { margin-top: 12px; }
+
+    .empty-state {
+      text-align: center;
+      color: var(--text-dim);
+      font-size: 14px;
+      margin-top: 48px;
+    }
+
+    /* ── Bubbles ── */
+    .msg-wrap { display: flex; }
+    .msg-wrap-mine { justify-content: flex-end; }
+    .msg-wrap-theirs { justify-content: flex-start; }
+
+    .bubble {
+      max-width: min(72%, 480px);
+      padding: 10px 14px 6px;
+      border-radius: var(--radius);
+      word-break: break-word;
+      line-height: 1.45;
+    }
+
+    .bubble-mine {
+      background: var(--mine-bg);
+      border: 1px solid var(--mine-border);
+      border-bottom-right-radius: var(--radius-sm);
+    }
+    .bubble-theirs {
+      background: var(--theirs-bg);
+      border: 1px solid var(--theirs-border);
+      border-bottom-left-radius: var(--radius-sm);
+    }
+
+    .bubble-body { font-size: 14.5px; }
+    .bubble-time {
+      font-size: 10px;
+      color: var(--text-dim);
+      margin-top: 4px;
+      display: flex;
+      align-items: center;
+      gap: 4px;
+    }
+    .msg-wrap-mine .bubble-time { justify-content: flex-end; }
+
+    .unread-dot {
+      width: 6px; height: 6px;
+      border-radius: 50%;
+      background: var(--accent);
+      flex-shrink: 0;
+    }
+
+    /* ── Input bar ── */
+    .input-bar {
+      flex-shrink: 0;
+      background: var(--surface);
+      border-top: 1px solid var(--border);
+      padding: 10px 12px;
+      padding-bottom: calc(10px + env(safe-area-inset-bottom));
+    }
+
+    .input-form { display: flex; gap: 8px; align-items: flex-end; }
+
+    .input-textarea {
+      flex: 1;
+      background: var(--surface2);
+      border: 1px solid var(--border);
+      border-radius: 22px;
+      color: var(--text);
+      font-size: 15px;
+      line-height: 1.4;
+      padding: 10px 16px;
+      resize: none;
+      min-height: 44px;
+      max-height: 120px;
+      overflow-y: auto;
+      outline: none;
+      font-family: inherit;
+      transition: border-color 0.15s;
+    }
+    .input-textarea:focus { border-color: var(--accent-dim); }
+    .input-textarea::placeholder { color: var(--text-dim); }
+
+    .send-btn {
+      width: 44px; height: 44px;
+      border-radius: 50%;
+      background: var(--accent);
+      border: none;
+      color: #fff;
+      cursor: pointer;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      flex-shrink: 0;
+      transition: background 0.15s, transform 0.1s;
+    }
+    .send-btn:hover { background: #7fa0ff; }
+    .send-btn:active { transform: scale(0.93); }
+    .send-btn svg { width: 20px; height: 20px; }
+
+    /* ── Send error feedback ── */
+    #send-status { min-height: 0; }
+    .send-err { color: var(--red); font-size: 12px; }
+
+    /* ── HTMX request indicator ── */
+    .htmx-request .send-btn { background: var(--accent-dim); }
+  </style>
+</head>
+<body>
+<div class="app">
+
+  <!-- Header -->
+  <div class="header">
+    <div class="avatar">${escapeHtml(coworker.charAt(0).toUpperCase())}</div>
+    <div class="header-info">
+      <div class="header-name">${escapeHtml(coworker)}</div>
+      <div class="header-sub"
+           id="coworker-status"
+           hx-get="/status"
+           hx-trigger="load, every 5s"
+           hx-swap="innerHTML"></div>
+    </div>
+    <button class="reset-btn"
+            hx-post="/reset"
+            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-on::after-request="showResetStatus()"
+            title="Reset session">
+      ↺ Reset
+    </button>
+    <div class="refresh-indicator" id="refresh-dot"
+         hx-get="/ping"
+         hx-trigger="every 5s"
+         hx-swap="none"
+         hx-on::before-request="this.classList.add('active')"
+         hx-on::after-request="this.classList.remove('active')"></div>
+  </div>
+
+  <div id="reset-status"></div>
+
+  <!-- Messages -->
+  <div class="messages-outer" id="messages-outer">
+    <div id="messages"
+         hx-get="/messages"
+         hx-trigger="load, every 5s"
+         hx-swap="innerHTML">
+      ${msgsHtml}
+    </div>
+  </div>
+
+  <!-- Input -->
+  <div class="input-bar">
+    <div id="send-status"></div>
+    <form class="input-form"
+          hx-post="/send"
+          hx-target="#send-status"
+          hx-swap="innerHTML show:no-scroll"
+          hx-on::after-request="handleSent(event)"
+          hx-on::before-request="this.querySelector('.send-btn').disabled=true"
+          hx-encoding="application/x-www-form-urlencoded">
+      <textarea
+        class="input-textarea"
+        name="body"
+        id="msg-input"
+        placeholder="Message ${escapeHtml(coworker)}…"
+        rows="1"
+        autocomplete="off"
+        autocorrect="on"
+        spellcheck="true"
+        onkeydown="handleKey(event)"></textarea>
+      <button type="submit" class="send-btn" title="Send">
+        <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+          <line x1="22" y1="2" x2="11" y2="13"></line>
+          <polygon points="22 2 15 22 11 13 2 9 22 2"></polygon>
+        </svg>
+      </button>
+    </form>
+  </div>
+
+</div>
+
+<script>
+  const outer = document.getElementById('messages-outer')
+  const input = document.getElementById('msg-input')
+
+  let lastSeenId = parseInt(document.querySelector('#messages-inner')?.dataset?.lastId ?? '0', 10)
+
+  function scrollToBottom() {
+    if (outer) outer.scrollTop = outer.scrollHeight
+  }
+
+  function isNearBottom() {
+    return outer.scrollHeight - outer.scrollTop - outer.clientHeight < 80
+  }
+
+  // Auto-grow textarea
+  input.addEventListener('input', function() {
+    this.style.height = 'auto'
+    this.style.height = Math.min(this.scrollHeight, 120) + 'px'
+  })
+
+  // Send on Enter (Shift+Enter = newline)
+  function handleKey(e) {
+    if (e.key === 'Enter' && !e.shiftKey) {
+      e.preventDefault()
+      const form = e.target.closest('form')
+      if (form && input.value.trim()) htmx.trigger(form, 'submit')
+    }
+  }
+
+  // After send: clear input, re-enable button, trigger refresh
+  function handleSent(event) {
+    const form = event.target
+    form.querySelector('.send-btn').disabled = false
+    if (event.detail.successful) {
+      input.value = ''
+      input.style.height = 'auto'
+      // Force scroll on the next swap since we just sent a message
+      lastSeenId = -1
+      htmx.trigger(document.getElementById('messages'), 'load')
+    }
+  }
+
+  // Only scroll to bottom when new messages actually arrive
+  document.addEventListener('htmx:afterSwap', (e) => {
+    if (e.detail.target.id !== 'messages') return
+    const inner = document.getElementById('messages-inner')
+    const newLastId = parseInt(inner?.dataset?.lastId ?? '0', 10)
+    if (newLastId > lastSeenId) {
+      lastSeenId = newLastId
+      if (isNearBottom()) scrollToBottom()
+    }
+  })
+
+  // Initial scroll
+  scrollToBottom()
+
+  // Flash the reset status toast then fade it out
+  function showResetStatus() {
+    const el = document.getElementById('reset-status')
+    if (!el) return
+    el.classList.add('visible')
+    clearTimeout(el._hideTimer)
+    el._hideTimer = setTimeout(() => el.classList.remove('visible'), 3000)
+  }
+</script>
+</body>
+</html>`;
+}
+// ── Express app ───────────────────────────────────────────────────────────────
+export async function communicatorWeb(coworker, options) {
+    const { url: agentUrl, secret, host, port: portStr } = options;
+    const port = parseInt(portStr, 10);
+    if (isNaN(port) || port < 1 || port > 65535) {
+        console.error(`Error: invalid port "${portStr}"`);
+        process.exit(1);
+    }
+    try {
+        new URL(agentUrl);
+    }
+    catch {
+        console.error(`Error: invalid --url "${agentUrl}"`);
+        process.exit(1);
+    }
+    // Resolve human name once at startup
+    let humanName = "Human";
+    try {
+        humanName = await getHumanName(agentUrl, secret);
+    }
+    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.log(`Communicator: chatting as "${humanName}" with "${coworker}"`);
+    const app = express();
+    app.use(express.urlencoded({ extended: false }));
+    app.use(express.json());
+    // ── GET / — full page ────────────────────────────────────────────────────
+    app.get("/", async (_req, res) => {
+        try {
+            const msgs = await fetchMessages(agentUrl, secret, humanName, coworker);
+            res.setHeader("Content-Type", "text/html; charset=utf-8");
+            res.send(renderPage(coworker, msgs, humanName));
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            res.status(502).send(`<pre>Error connecting to agent-office: ${escapeHtml(msg)}</pre>`);
+        }
+    });
+    // ── GET /messages — HTMX fragment (polled every 5s) ──────────────────────
+    app.get("/messages", async (_req, res) => {
+        try {
+            const msgs = await fetchMessages(agentUrl, secret, 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)));
+            res.setHeader("Content-Type", "text/html; charset=utf-8");
+            res.send(renderMessages(msgs, humanName));
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            res.setHeader("Content-Type", "text/html; charset=utf-8");
+            res.send(`<div class="empty-state" style="color:#ff6b6b">Error: ${escapeHtml(msg)}</div>`);
+        }
+    });
+    // ── POST /send — HTMX form submit ────────────────────────────────────────
+    app.post("/send", async (req, res) => {
+        const body = req.body.body?.trim();
+        if (!body) {
+            res.setHeader("Content-Type", "text/html; charset=utf-8");
+            res.send(`<span class="send-err">Message cannot be empty.</span>`);
+            return;
+        }
+        try {
+            await apiFetch(agentUrl, secret, "/messages", {
+                method: "POST",
+                body: JSON.stringify({ from: humanName, to: [coworker], body }),
+            });
+            res.setHeader("Content-Type", "text/html; charset=utf-8");
+            res.send("");
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            res.setHeader("Content-Type", "text/html; charset=utf-8");
+            res.send(`<span class="send-err">Failed: ${escapeHtml(msg)}</span>`);
+        }
+    });
+    // ── GET /status — coworker status fragment (polled every 5s) ────────────
+    app.get("/status", async (_req, res) => {
+        res.setHeader("Content-Type", "text/html; charset=utf-8");
+        try {
+            const status = await fetchCoworkerStatus(agentUrl, secret, coworker);
+            res.send(status ? escapeHtml(status) : `<span style="color:var(--text-dim)">—</span>`);
+        }
+        catch {
+            res.send(`<span style="color:var(--text-dim)">—</span>`);
+        }
+    });
+    // ── POST /reset — revert the coworker's session to first message ─────────
+    app.post("/reset", async (_req, res) => {
+        res.setHeader("Content-Type", "text/html; charset=utf-8");
+        try {
+            await apiFetch(agentUrl, secret, `/sessions/${encodeURIComponent(coworker)}/revert-to-start`, {
+                method: "POST",
+            });
+            res.send(`<span style="color:var(--green)">✓ ${escapeHtml(coworker)} reset and restarted.</span>`);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            res.send(`<span style="color:var(--red)">✗ Reset failed: ${escapeHtml(msg)}</span>`);
+        }
+    });
+    // ── GET /ping — keeps the refresh dot alive ───────────────────────────────
+    app.get("/ping", (_req, res) => {
+        res.status(204).end();
+    });
+    app.listen(port, host, () => {
+        console.log(`Communicator running at http://${host}:${port}`);
+        console.log(`Press Ctrl+C to stop.`);
+    });
+    // Keep process alive
+    await new Promise(() => { });
+}

package/dist/commands/serve.d.ts

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