agentp 0.4.0 → 0.5.0

package/lib/ocmux.js

@@ -0,0 +1,156 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+const SESSION = 'Opencode';
+
+function _tmux(args) {
+  const result = spawnSync('tmux', args, { encoding: 'utf8', maxBuffer: 1024 * 1024 });
+  if (result.error && result.error.code === 'ENOENT') {
+    return { status: -1, stdout: '', stderr: 'tmux not found' };
+  }
+  return result;
+}
+
+function readState(file) {
+  try {
+    return JSON.parse(fs.readFileSync(file, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function statefileFor(dir) {
+  return path.join(dir, '.ocmux.json');
+}
+
+function tuiPaneId(windowIndex) {
+  const r = _tmux(['list-panes', '-t', `${SESSION}:${windowIndex}`, '-F', '#{pane_id}\t#{pane_current_command}']);
+  if (r.status !== 0) return null;
+  for (const line of r.stdout.trim().split('\n').filter(Boolean)) {
+    const [paneId, cmd] = line.split('\t');
+    if (cmd === 'node') return paneId;
+  }
+  return null;
+}
+
+function windowByDir(dir) {
+  const r = _tmux(['list-windows', '-t', SESSION, '-F', '#{window_index}\t#{window_name}']);
+  if (r.status !== 0) return null;
+  for (const line of r.stdout.trim().split('\n').filter(Boolean)) {
+    const [idx, name] = line.split('\t');
+    if (name === dir) return parseInt(idx, 10);
+  }
+  return null;
+}
+
+function windowNameByIndex(idx) {
+  const r = _tmux(['list-windows', '-t', SESSION, '-F', '#{window_index}\t#{window_name}']);
+  if (r.status !== 0) return null;
+  for (const line of r.stdout.trim().split('\n').filter(Boolean)) {
+    const [wi, name] = line.split('\t');
+    if (parseInt(wi, 10) === idx) return name;
+  }
+  return null;
+}
+
+function activeWindowIndex() {
+  const r = _tmux(['list-windows', '-t', SESSION, '-F', '#{window_index} #{window_active}']);
+  if (r.status !== 0) return null;
+  for (const line of r.stdout.trim().split('\n').filter(Boolean)) {
+    const [idx, active] = line.split(' ');
+    if (active === '1') return parseInt(idx, 10);
+  }
+  return null;
+}
+
+function paneCount(windowIndex) {
+  const r = _tmux(['list-panes', '-t', `${SESSION}:${windowIndex}`, '-F', '#{pane_id}']);
+  if (r.status !== 0) return 0;
+  return r.stdout.trim().split('\n').filter(Boolean).length;
+}
+
+function listServers() {
+  const sessionR = _tmux(['has-session', '-t', SESSION]);
+  if (sessionR.status !== 0) return [];
+
+  const listR = _tmux(['list-windows', '-t', SESSION, '-F', '#{window_index}\t#{window_name}']);
+  if (listR.status !== 0 || !listR.stdout.trim()) return [];
+
+  const rows = [];
+  for (const line of listR.stdout.trim().split('\n').filter(Boolean)) {
+    const [idx, dir] = line.split('\t');
+    const sf = statefileFor(dir);
+    if (!fs.existsSync(sf)) continue;
+    const state = readState(sf);
+    if (!state || !state.url) continue;
+    const tui = tuiPaneId(parseInt(idx, 10));
+    rows.push({ url: state.url, dir, index: parseInt(idx, 10), status: tui ? 'alive' : 'dead' });
+  }
+  return rows;
+}
+
+// Switch tmux focus to the given server window and ensure the TUI pane is alive and zoomed.
+function activateServer(dir, index, url) {
+  const winIdx = index;
+
+  // Pin window name
+  _tmux(['set-window-option', '-t', `${SESSION}:${winIdx}`, 'automatic-rename', 'off']);
+
+  // Restart TUI pane if dead
+  const tuiPane = tuiPaneId(winIdx);
+  if (!tuiPane) {
+    const count = paneCount(winIdx);
+    if (count >= 2) {
+      const panesR = _tmux(['list-panes', '-t', `${SESSION}:${winIdx}`, '-F', '#{pane_id}']);
+      if (panesR.status === 0) {
+        const panes = panesR.stdout.trim().split('\n').filter(Boolean);
+        const lastPane = panes[panes.length - 1];
+        const respawnR = _tmux(['respawn-pane', '-k', '-t', lastPane, `opencode attach --continue '${url}'`]);
+        if (respawnR.status !== 0) {
+          _tmux(['send-keys', '-t', lastPane, `opencode attach --continue '${url}'`, 'Enter']);
+        }
+      }
+    } else {
+      _tmux(['split-window', '-v', '-t', `${SESSION}:${winIdx}`, '-c', dir,
+        `opencode attach --continue '${url}'`]);
+    }
+  }
+
+  // Select window
+  const activeWin = activeWindowIndex();
+  if (activeWin !== null && activeWin !== winIdx) {
+    _tmux(['select-window', '-t', `${SESSION}:${winIdx}`]);
+  }
+
+  // Zoom TUI pane
+  const zoomR = _tmux(['list-windows', '-t', SESSION, '-F', '#{window_index}|#{window_zoomed_flag}']);
+  if (zoomR.status === 0) {
+    let zoomed = false;
+    for (const line of zoomR.stdout.trim().split('\n').filter(Boolean)) {
+      const [wi, z] = line.split('|');
+      if (parseInt(wi, 10) === winIdx && z === '1') { zoomed = true; break; }
+    }
+    if (!zoomed) {
+      const tui = tuiPaneId(winIdx);
+      if (tui) _tmux(['resize-pane', '-Z', '-t', tui]);
+    }
+  }
+
+  return true;
+}
+
+module.exports = {
+  SESSION,
+  readState,
+  statefileFor,
+  tuiPaneId,
+  windowByDir,
+  windowNameByIndex,
+  activeWindowIndex,
+  paneCount,
+  listServers,
+  activateServer,
+};

package/lib/opencode.js

@@ -0,0 +1,270 @@
+'use strict';
+
+const http = require('http');
+const { URL } = require('url');
+
+function getAuthHeaders() {
+  const password = process.env.OPENCODE_SERVER_PASSWORD;
+  if (!password) return {};
+  const username = process.env.OPENCODE_SERVER_USERNAME || 'opencode';
+  const encoded = Buffer.from(`${username}:${password}`).toString('base64');
+  return { 'Authorization': `Basic ${encoded}` };
+}
+
+function makeRequest(options, data) {
+  return new Promise((resolve, reject) => {
+    const req = http.request(options, (res) => {
+      let body = '';
+      res.on('data', (chunk) => { body += chunk; });
+      res.on('end', () => {
+        if (res.statusCode === 401) {
+          reject(new Error('OpenCode server authentication failed. Set OPENCODE_SERVER_PASSWORD to match the server password.'));
+        } else {
+          resolve({ status: res.statusCode, body });
+        }
+      });
+    });
+    req.on('error', reject);
+    if (data) req.write(data);
+    req.end();
+  });
+}
+
+function buildJsonRequest(url, method, body) {
+  const parsed = new URL(url);
+  const opts = {
+    hostname: parsed.hostname,
+    port: parsed.port,
+    path: parsed.pathname + (parsed.search || ''),
+    method,
+    headers: { ...getAuthHeaders() }
+  };
+  if (body != null) {
+    opts.headers['Content-Type'] = 'application/json';
+    opts.headers['Content-Length'] = Buffer.byteLength(body);
+  }
+  return opts;
+}
+
+async function clearPrompt(server) {
+  const url = `${server}/tui/clear-prompt`;
+  await makeRequest(buildJsonRequest(url, 'POST', '{}'), '{}');
+}
+
+async function appendPrompt(server, text) {
+  const url = `${server}/tui/append-prompt`;
+  const body = JSON.stringify({ text });
+  await makeRequest(buildJsonRequest(url, 'POST', body), body);
+}
+
+async function submitPrompt(server) {
+  const url = `${server}/tui/submit-prompt`;
+  await makeRequest(buildJsonRequest(url, 'POST', '{}'), '{}');
+}
+
+// Send a complete text string as a prompt (clear + append + submit).
+async function sendText(server, text) {
+  await clearPrompt(server);
+  await appendPrompt(server, text);
+  await submitPrompt(server);
+}
+
+// Listen for the final answer from the OpenCode event stream.
+// onText(chunk) is called for each text part received (optional; defaults to no-op).
+// cancelRef — if provided, { current: null } is populated with the request so it can be aborted.
+// Returns a Promise that resolves with the full collected response string.
+function listenForFinalAnswer(server, onText, cancelRef) {
+  return new Promise((resolve, reject) => {
+    const url = `${server}/event`;
+    const parsed = new URL(url);
+    const write = typeof onText === 'function' ? onText : null;
+
+    const req = http.request({
+      hostname: parsed.hostname,
+      port: parsed.port,
+      path: parsed.pathname,
+      method: 'GET',
+      headers: { 'Accept': 'text/event-stream', ...getAuthHeaders() }
+    }, (res) => {
+      if (res.statusCode === 401) {
+        res.resume();
+        reject(new Error('OpenCode server authentication failed. Set OPENCODE_SERVER_PASSWORD to match the server password.'));
+        return;
+      }
+      let buffer = '';
+      const userMessageIDs = new Set();
+      let collected = '';
+
+      res.on('data', (chunk) => {
+        buffer += chunk.toString();
+
+        // Split by double newline (SSE event separator)
+        while (buffer.includes('\n\n')) {
+          const eventEnd = buffer.indexOf('\n\n');
+          const eventData = buffer.slice(0, eventEnd);
+          buffer = buffer.slice(eventEnd + 2);
+
+          // Extract data lines
+          const lines = eventData.split('\n');
+          let jsonStr = '';
+
+          for (const line of lines) {
+            if (line.startsWith('data: ')) {
+              jsonStr += line.slice(6);
+            }
+          }
+
+          if (!jsonStr.trim()) continue;
+
+          try {
+            const event = JSON.parse(jsonStr);
+
+            // Track user message IDs
+            if (event.type === 'message.updated' && event.properties?.info?.role === 'user') {
+              userMessageIDs.add(event.properties.info.id);
+            }
+
+            // Check for session.idle to detect completion
+            if (event.type === 'session.idle') {
+              cleanup();
+              req.destroy();
+              res.destroy();
+              resolve(collected);
+              return;
+            }
+
+            const part = event.properties?.part;
+            if (!part) continue;
+
+            // Filter out user input by checking messageID
+            if (part.messageID && userMessageIDs.has(part.messageID)) {
+              continue;
+            }
+
+            if (part.type === 'text' && part.text != null && part.text !== '') {
+              if (write) write(part.text);
+              collected += part.text;
+            }
+          } catch (e) {
+            // Malformed SSE event — skip and continue processing
+          }
+        }
+      });
+
+      res.on('end', () => {
+        cleanup();
+        resolve(collected);
+      });
+    });
+
+    const cleanup = () => {
+      if (cancelRef) cancelRef.current = null;
+    };
+
+    req.on('error', (err) => {
+      cleanup();
+      reject(err);
+    });
+
+    if (cancelRef) cancelRef.current = req;
+    req.end();
+  });
+}
+
+// List all sessions from the OpenCode server.
+// Optionally filter by project directory.
+async function listSessions(server, directory) {
+  let url = `${server}/session`;
+  if (directory) url += '?directory=' + encodeURIComponent(directory);
+  const { status, body } = await makeRequest(buildJsonRequest(url, 'GET'));
+  if (status !== 200) throw new Error(`Failed to list sessions: ${status}`);
+  return JSON.parse(body);
+}
+
+// Send a message directly to a specific session via the 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) {
+  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);
+  if (status !== 200) throw new Error(`Failed to send to session: ${status}`);
+  const result = JSON.parse(responseBody);
+  const texts = (result.parts || [])
+    .filter(p => p.type === 'text')
+    .map(p => p.text)
+    .join('');
+  return texts;
+}
+
+// Create a new session on the OpenCode server. Optionally set a title.
+async function createSession(server, title) {
+  const url = `${server}/session`;
+  const body = JSON.stringify(title != null ? { title } : {});
+  const { status, body: responseBody } = await makeRequest(buildJsonRequest(url, 'POST', body), body);
+  if (status !== 200) throw new Error(`Failed to create session: ${status}`);
+  return JSON.parse(responseBody);
+}
+
+// Update a session's properties (e.g. title).
+async function updateSession(server, sessionId, title) {
+  const url = `${server}/session/${encodeURIComponent(sessionId)}`;
+  const body = JSON.stringify({ title });
+  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);
+}
+
+// Tell the TUI to navigate to a specific session (if a TUI is attached).
+// Tries multiple approaches since the endpoint varies by opencode version.
+async function selectSession(server, sessionId) {
+  const encoded = encodeURIComponent(sessionId);
+  const attempts = [
+    { url: `${server}/session/${encoded}/select`, body: '{}' },
+    { url: `${server}/tui/select-session`, body: JSON.stringify({ sessionID: sessionId }) },
+  ];
+  for (const { url, body } of attempts) {
+    try {
+      await makeRequest(buildJsonRequest(url, 'POST', body), body);
+      return;
+    } catch {
+      // try next approach
+    }
+  }
+}
+
+// List all agents from the OpenCode server.
+async function listAgents(server) {
+  const url = `${server}/agent`;
+  const { status, body } = await makeRequest(buildJsonRequest(url, 'GET'));
+  if (status !== 200) throw new Error(`Failed to list agents: ${status}`);
+  return JSON.parse(body);
+}
+
+// List all providers/models from the OpenCode server.
+async function listProviders(server) {
+  const url = `${server}/provider`;
+  const { status, body } = await makeRequest(buildJsonRequest(url, 'GET'));
+  if (status !== 200) throw new Error(`Failed to list providers: ${status}`);
+  return JSON.parse(body);
+}
+
+module.exports = {
+  getAuthHeaders,
+  makeRequest,
+  buildJsonRequest,
+  clearPrompt,
+  appendPrompt,
+  submitPrompt,
+  sendText,
+  listenForFinalAnswer,
+  listSessions,
+  createSession,
+  updateSession,
+  selectSession,
+  sendToSession,
+  listAgents,
+  listProviders,
+};

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "agentp",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "Pipe prompts into a running OpenCode TUI session and stream the final answer",
   "bin": {
     "agentp": "bin/agentp",
-    "ocmux": "bin/ocmux"
+    "ocmux": "bin/ocmux",
+    "tgagentp": "bin/tgagentp"
   },
   "keywords": [
     "ai",