agentp 0.8.0 → 0.10.0

package/devto-article.md

@@ -0,0 +1,121 @@
+# Agentp: Turn OpenCode Into a Headless AI Engine for Your Editor, Terminal, and Telegram
+
+OpenCode is great, but its TUI locks you in. You type in one window, watch it stream, and that's it. What if you could:
+
+- Pipe a prompt straight from Vim and replace your selection with the answer?
+- Queue messages from Telegram while it's busy and get replies threaded?
+- Keep a permanent tmux server per project and switch between them?
+- Pull the last N answers from session history without sending a new prompt?
+- Record your Telegram conversation and inject it as context into your next `agentp` call?
+
+That's what **agentp** — a set of three zero-dependency Node.js CLI tools — does.
+
+---
+
+## The Three Tools
+
+### `agentp` — The Pipe
+
+Stdin in, answer out. That's the core loop.
+
+```bash
+printf "Summarize this file" | agentp
+cat prompt.txt | agentp 4096
+```
+
+From Vim/Neovim:
+
+```vim
+:'<,'>!agentp --qa
+```
+
+This replaces your visual selection with the answer. `--qa` preserves the prompt + answer with labels, so you keep the full context.
+
+### `ocmux` — The Project Manager
+
+Each project gets its own tmux window with a dedicated `opencode serve` + TUI pane. Auto-restarts dead panes, pins window names, stores state in `.ocmux.json` (discovered upward like `.git`).
+
+```bash
+ocmux serve ~/projects/myapp   # create
+ocmux list                      # list all
+ocmux ~/projects/myapp          # switch
+ocmux kill ~/projects/myapp     # remove
+```
+
+### `tgagentp` — The Telegram Bridge
+
+A Telegram bot that routes messages to your OpenCode servers. Multi-server aware, slash-commands for everything.
+
+**Slash commands:**
+
+| Command | What it does |
+|---|---|
+| `/servers` | List/switch between ocmux projects |
+| `/sessions` | List/switch/create/rename sessions |
+| `/agents` | List/switch active agent |
+| `/models` | List providers and models |
+| `/queue <msg>` | Queue message when busy — auto-sent after current task finishes (replies chain!) |
+| `/record` | Record conversation for `agentp` context injection |
+| `/think` | Toggle real-time thinking message forwarding |
+| `/cancel` | Abort the running prompt |
+
+---
+
+## The Agentp Gateway
+
+The killer integration: `agentp` and `tgagentp` talk to each other through a tiny HTTP gateway.
+
+- **`agentp --tg`** forwards the answer to your Telegram chat after every pipe.
+- **`agentp --qa`** auto-detects tgagentp and sends the full QA pair (rulers + prompt + answer).
+- **`/record`** buffers the Telegram conversation. On the next `agentp` call, the gateway returns the buffer, and `--qa` prepends it to stdout with rulers — so OpenCode sees the full Telegram thread as context.
+- **`agentp --flush`** clears the buffer without prepending.
+- **`agentp --getLast 5`** retrieves the last 5 assistant answers from session history.
+
+```vim
+:'<,'>!agentp --qa --tg          " answer in editor + Telegram
+:'<,'>!agentp --qa --flush       " flush recorded buffer
+```
+
+All of this with **zero npm dependencies** — just Node.js 18+ stdlib.
+
+---
+
+## Why This Setup Works
+
+1. **Session API, not TUI hooks** — messages go through `POST /session/:id/message`, which returns synchronously. No fragile TUI scraping.
+2. **Per-project tmux isolation** — each project gets its own `opencode serve` process. Switch with a single command.
+3. **Graceful degradation** — `--tg` in auto mode silently skips Telegram if tgagentp isn't running. Explicit `--tg` errors pre-send, warns post-send.
+4. **10s HTTP timeout on every request** — nothing ever hangs.
+5. **Async processing** — tgagentp never blocks the polling loop. Commands stay responsive even while a prompt runs.
+
+---
+
+## Quick Start
+
+```bash
+npm install -g agentp
+
+# Start a project server
+ocmux serve ~/projects/myapp
+
+# Pipe a prompt
+printf "Explain this codebase" | agentp
+
+# With Telegram (set up a bot with @BotFather first)
+export TELEGRAM_BOT_TOKEN="your-token"
+tgagentp
+```
+
+If your OpenCode server is password-protected, set `OPENCODE_SERVER_PASSWORD`.
+
+---
+
+## Links
+
+- **GitHub:** [github.com/bitifet/agentp](https://github.com/bitifet/agentp)
+- **npm:** [npmjs.com/package/agentp](https://www.npmjs.com/package/agentp)
+- **OpenCode:** [github.com/anthropics/claude-code](https://github.com/anthropics/claude-code)
+
+---
+
+*Feedback? Issues? PRs welcome.*

package/lib/opencode.js

@@ -11,7 +11,7 @@ function getAuthHeaders() {
   return { 'Authorization': `Basic ${encoded}` };
 }
 
-function makeRequest(options, data) {
+function makeRequest(options, data, cancelRef, timeoutMs) {
   return new Promise((resolve, reject) => {
     const req = http.request(options, (res) => {
       let body = '';
@@ -24,7 +24,14 @@ function makeRequest(options, data) {
         }
       });
     });
+    if (timeoutMs) {
+      req.setTimeout(timeoutMs, () => {
+        req.destroy();
+        reject(new Error('Request timed out'));
+      });
+    }
     req.on('error', reject);
+    if (cancelRef) cancelRef.current = req;
     if (data) req.write(data);
     req.end();
   });
@@ -181,15 +188,16 @@ async function listSessions(server, directory) {
   return JSON.parse(body);
 }
 
-// Send a message directly to a specific session via the session API.
+// Send a message directly to a specific session via the synchronous session API.
 // Returns the collected text from all text parts in the response.
 // Optionally specify an agent to handle the message.
-async function sendToSession(server, sessionId, text, agent) {
+// Optional cancelRef allows aborting the HTTP request (for /cancel support).
+async function sendToSession(server, sessionId, text, agent, cancelRef) {
   const url = `${server}/session/${encodeURIComponent(sessionId)}/message`;
   const bodyObj = { parts: [{ type: 'text', text }] };
   if (agent) bodyObj.agent = agent;
   const body = JSON.stringify(bodyObj);
-  const { status, body: responseBody } = await makeRequest(buildJsonRequest(url, 'POST', body), body);
+  const { status, body: responseBody } = await makeRequest(buildJsonRequest(url, 'POST', body), body, cancelRef);
   if (status !== 200) throw new Error(`Failed to send to session: ${status}`);
   const result = JSON.parse(responseBody);
   const texts = (result.parts || [])
@@ -209,9 +217,12 @@ async function createSession(server, title) {
 }
 
 // Update a session's properties (e.g. title).
-async function updateSession(server, sessionId, title) {
+async function updateSession(server, sessionId, title, agent) {
+  const bodyObj = {};
+  if (title != null) bodyObj.title = title;
+  if (agent != null) bodyObj.agent = agent;
   const url = `${server}/session/${encodeURIComponent(sessionId)}`;
-  const body = JSON.stringify({ title });
+  const body = JSON.stringify(bodyObj);
   const { status, body: responseBody } = await makeRequest(buildJsonRequest(url, 'PATCH', body), body);
   if (status !== 200) throw new Error(`Failed to update session: ${status}`);
   return JSON.parse(responseBody);
@@ -238,6 +249,27 @@ async function selectSession(server, sessionId) {
   }
 }
 
+// Get a single session by ID, including its message history.
+// Tries GET /session/:id first; falls back to filtering the sessions list.
+async function getSession(server, sessionId) {
+  // Try dedicated endpoint first (newer opencode versions)
+  try {
+    const url = `${server}/session/${encodeURIComponent(sessionId)}`;
+    const { status, body } = await makeRequest(buildJsonRequest(url, 'GET'), null, null, 10000);
+    if (status === 200) {
+      const parsed = JSON.parse(body);
+      if (parsed) return parsed;
+    }
+  } catch {
+    // Fall through
+  }
+  // Fallback: get all sessions and find the one we need
+  const sessions = await listSessions(server);
+  const match = sessions.find(s => String(s.id) === String(sessionId));
+  if (match) return match;
+  throw new Error(`Session ${sessionId} not found`);
+}
+
 // List all agents from the OpenCode server.
 async function listAgents(server) {
   const url = `${server}/agent`;
@@ -276,7 +308,7 @@ async function respondToPermission(server, sessionId, permissionId, response, re
 
 // Listen for session events via SSE, collecting assistant text parts and detecting
 // permission requests. Resolves with the full collected text when the session goes idle.
-// callbacks: { onText(chunk), onPermission(permission) }
+// callbacks: { onText(chunk), onPermission(permission), onThinking(chunk), onConnected() }
 // cancelRef — allows aborting the SSE stream via req.destroy()
 function listenForSessionEvents(server, sessionId, callbacks, cancelRef) {
   process.stderr.write(`  [SSE] connecting to ${server}/event for session ${sessionId}\n`);
@@ -297,9 +329,22 @@ function listenForSessionEvents(server, sessionId, callbacks, cancelRef) {
         return;
       }
       process.stderr.write(`  [SSE] connected for session ${sessionId}\n`);
+      if (callbacks.onConnected) callbacks.onConnected();
       let buffer = '';
       const userMessageIDs = new Set();
       let collected = '';
+      let resolved = false;
+
+      // Safety timeout: resolve with whatever we have after 90s
+      const safetyTimer = setTimeout(() => {
+        if (resolved) return;
+        resolved = true;
+        process.stderr.write(`  [SSE] safety timeout (90s) for session ${sessionId}, collected ${collected.length} chars\n`);
+        cleanup();
+        req.destroy();
+        res.destroy();
+        resolve(collected);
+      }, 90000);
 
       res.on('data', (chunk) => {
         buffer += chunk.toString();
@@ -325,8 +370,8 @@ function listenForSessionEvents(server, sessionId, callbacks, cancelRef) {
               process.stderr.write(`  [SSE] event type=${event.type} sessionID=${props.sessionID} waitSession=${sessionId}\n`);
             }
 
-            // Filter by sessionID when the event carries one
-            if (props.sessionID && props.sessionID !== sessionId) continue;
+            // Filter by sessionID when the event carries one (string-compare to handle type mismatches)
+            if (props.sessionID && String(props.sessionID) !== String(sessionId)) continue;
 
             if (event.type === 'message.updated' && props.info?.role === 'user') {
               userMessageIDs.add(props.info.id);
@@ -355,6 +400,9 @@ function listenForSessionEvents(server, sessionId, callbacks, cancelRef) {
 
             // Completion signals
             if (event.type === 'session.idle') {
+              clearTimeout(safetyTimer);
+              if (resolved) return;
+              resolved = true;
               cleanup();
               req.destroy();
               res.destroy();
@@ -362,6 +410,9 @@ function listenForSessionEvents(server, sessionId, callbacks, cancelRef) {
               return;
             }
             if (event.type === 'session.status' && props.status?.type === 'idle') {
+              clearTimeout(safetyTimer);
+              if (resolved) return;
+              resolved = true;
               cleanup();
               req.destroy();
               res.destroy();
@@ -390,9 +441,21 @@ function listenForSessionEvents(server, sessionId, callbacks, cancelRef) {
       });
 
       res.on('end', () => {
+        clearTimeout(safetyTimer);
+        if (resolved) return;
+        resolved = true;
         cleanup();
         resolve(collected);
       });
+
+      res.on('error', (err) => {
+        clearTimeout(safetyTimer);
+        if (resolved) return;
+        resolved = true;
+        cleanup();
+        process.stderr.write(`  [SSE] response stream error for session ${sessionId}: ${err.message}\n`);
+        resolve(collected);   // resolve with what we have
+      });
     });
 
     const cleanup = () => {
@@ -419,6 +482,7 @@ module.exports = {
   sendText,
   listenForFinalAnswer,
   listSessions,
+  getSession,
   createSession,
   updateSession,
   selectSession,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentp",
-  "version": "0.8.0",
+  "version": "0.10.0",
   "description": "Pipe prompts into a running OpenCode TUI session and stream the final answer",
   "bin": {
     "agentp": "bin/agentp",