agenter-app 1.1.0 → 1.3.0

package/server.js

@@ -13,6 +13,10 @@ const { truncate, describeTool, readTail, readHead, parseCodexItem, readTranscri
 const { normalizeLimits, codexWindowLabel } = require('./lib/limits');
 const { buildDiffs } = require('./lib/diff');
 const { getToken, sameToken } = require('./lib/token');
+const { version: VERSION } = require('./package.json');
+const updates = require('./lib/update');
+const { createTerminals } = require('./lib/terminal');
+const { readMemory, saveMemory, carriedContext } = require('./lib/memory');
 
 const PORT = Number(process.env.AGENTER_PORT) || 4317;
 const HOST = '127.0.0.1';
@@ -36,6 +40,9 @@ const DISCOVER_FULL_SCAN_MS = 5 * 60 * 1000; // when a file watcher catches chan
 const CREDENTIALS_FILE = path.join(os.homedir(), '.claude', '.credentials.json');
 const USAGE_URL = 'https://api.anthropic.com/api/oauth/usage';
 const USAGE_INTERVAL_MS = 2 * 60 * 1000;
+// A window opening also checks, so a long-running server still tells you about updates.
+const UPDATE_INTERVAL_MS = 6 * 60 * 60 * 1000;
+const UPDATE_THROTTLE_MS = 60 * 1000;
 
 const sessions = new Map(); // session_id -> session
 const pending = new Map(); // pending id -> { item, res, payload }
@@ -463,6 +470,56 @@ function noteCodexLimits(rl, at) {
   codexUsage = { updatedAt: at, plan: rl.plan_type || '', limits, credits: rl.credits || null };
 }
 
+// ---------- updates ----------
+
+let latestVersion = updates.cachedLatest();
+let updateCheckedAt = 0;
+
+async function checkForUpdate() {
+  if (!updates.enabled()) return;
+  updateCheckedAt = Date.now();
+  latestVersion = (await updates.checkLatest({ timeoutMs: 10000 })) || latestVersion;
+  broadcast();
+}
+
+function updateState() {
+  const installed = updates.installedVersion();
+  return {
+    current: VERSION,
+    latest: latestVersion,
+    installed,
+    available: updates.isNewer(latestVersion, VERSION) && !updates.isNewer(installed, VERSION),
+    restart: updates.isNewer(installed, VERSION), // installed, but this server is still the old code
+    canSelfUpdate: updates.canSelfUpdate(),
+  };
+}
+
+// ---------- terminal ----------
+
+const TERMINAL_ENABLED = process.platform === 'win32' && process.env.AGENTER_TERMINAL !== '0';
+const terminals = createTerminals((e) => sendAll('terminal', e));
+const terminalId = (cwd) => path.resolve(cwd).toLowerCase();
+
+// ---------- folder window ----------
+// The dashboard can't browse this machine's folders itself, so the server opens Windows' own.
+
+let pickingFolder = null;
+
+function pickFolder(start) {
+  return new Promise((resolve) => {
+    if (pickingFolder) return resolve({ busy: true });
+    if (process.platform !== 'win32') return resolve({ unsupported: true });
+    const args = ['-NoProfile', '-ExecutionPolicy', 'Bypass', '-STA', '-File', path.join(__dirname, 'scripts', 'pick-folder.ps1')];
+    pickingFolder = execFile('powershell.exe', args, { windowsHide: true, env: { ...process.env, AGENTER_PICK_START: String(start || '') } }, (err, out) => {
+      pickingFolder = null;
+      onAttentionChanged();
+      const folder = String(out || '').trim();
+      resolve(err ? { unsupported: true } : folder ? { path: folder } : { cancelled: true });
+    });
+    onAttentionChanged();
+  });
+}
+
 function openInVSCode(cwd) {
   if (!cwd || /["&|<>^%]/.test(cwd) || !fs.existsSync(cwd)) return false;
   const child =
@@ -660,7 +717,8 @@ function respond(id, action, body = {}) {
 
 // Sessions are only held while a dashboard window has focus. If you're in VS Code,
 // Claude finishes (or asks) there as usual instead of spinning on the dashboard.
-const inUse = () => [...clients.values()].some((c) => c.focused);
+// The folder window takes focus from the dashboard, but you're still here.
+const inUse = () => !!pickingFolder || [...clients.values()].some((c) => c.focused);
 
 let releaseTimer = null;
 function onAttentionChanged() {
@@ -673,15 +731,24 @@ function onAttentionChanged() {
 }
 
 // Quit, from the tray. Open windows close themselves on the 'quit' event.
-function stopServer() {
-  for (const c of clients.keys()) c.write('event: quit\ndata: {}\n\n');
+// A restart (to finish an update) leaves them open; they reconnect to the new server.
+function stopServer({ restart = false } = {}) {
+  if (!restart) sendAll('quit', {});
   for (const id of [...pending.keys()]) respond(id, 'pass');
   for (const child of runners.values()) {
     child.interrupted = true;
     killRun(child);
   }
-  fs.mkdirSync(SETTINGS_DIR, { recursive: true });
-  fs.writeFileSync(STOPPED_FILE, '');
+  terminals.killAll();
+  pickingFolder?.kill();
+  if (restart) {
+    // It waits for this process to let go of the port.
+    const env = { ...process.env, AGENTER_RESTART: '1' };
+    spawn(process.execPath, [path.join(__dirname, 'server.js'), '--no-open'], { detached: true, stdio: 'ignore', windowsHide: true, env }).unref();
+  } else {
+    fs.mkdirSync(SETTINGS_DIR, { recursive: true });
+    fs.writeFileSync(STOPPED_FILE, '');
+  }
   // Long enough for the hooks to receive those answers.
   setTimeout(() => process.exit(0), 300);
 }
@@ -929,6 +996,64 @@ function startCodexRun(s, text, { fresh = false } = {}) {
   });
 }
 
+// ---------- images ----------
+// Hooks and the CLIs only carry text, so pasted images are saved here and their paths go
+// into the message. Claude opens them with its Read tool, Codex with its image viewer.
+
+const UPLOADS_DIR = path.join(SETTINGS_DIR, 'uploads');
+const IMAGE_TYPES = { png: 'png', jpeg: 'jpg', gif: 'gif', webp: 'webp' };
+const MAX_IMAGES = 8;
+const MAX_IMAGE_BYTES = 10 * 1024 * 1024;
+
+// images: data: URLs from the dashboard. Returns the saved files' paths.
+function saveImages(images) {
+  if (!Array.isArray(images) || !images.length) return [];
+  if (images.length > MAX_IMAGES) throw new Error(`Attach at most ${MAX_IMAGES} images.`);
+  const files = images.map((src) => {
+    const m = /^data:image\/(png|jpeg|gif|webp);base64,([A-Za-z0-9+/=]+)$/.exec(String(src));
+    if (!m) throw new Error('Only PNG, JPEG, GIF and WebP images can be attached.');
+    const data = Buffer.from(m[2], 'base64');
+    if (data.length > MAX_IMAGE_BYTES) throw new Error('Each image must be under 10 MB.');
+    return { data, file: path.join(UPLOADS_DIR, `${crypto.randomUUID()}.${IMAGE_TYPES[m[1]]}`) };
+  });
+  fs.mkdirSync(UPLOADS_DIR, { recursive: true });
+  for (const f of files) fs.writeFileSync(f.file, f.data);
+  return files.map((f) => f.file);
+}
+
+function withImages(text, paths) {
+  text = String(text || '').trim();
+  if (!paths.length) return text;
+  const list = paths.map((p) => `- ${p}`).join('\n');
+  const note = `The user attached ${paths.length === 1 ? 'an image' : `${paths.length} images`}. Open ${paths.length === 1 ? 'it' : 'them'} to see:\n${list}`;
+  return text ? `${text}\n\n${note}` : note;
+}
+
+// Uploads only matter for the turn they went with; clear out old ones.
+function pruneUploads(maxAgeMs = 30 * 24 * 3600 * 1000) {
+  let names = [];
+  try {
+    names = fs.readdirSync(UPLOADS_DIR);
+  } catch {
+    return;
+  }
+  for (const n of names) {
+    const f = path.join(UPLOADS_DIR, n);
+    try {
+      if (Date.now() - fs.statSync(f).mtimeMs > maxAgeMs) fs.rmSync(f, { force: true });
+    } catch {}
+  }
+}
+
+// ---------- memory ----------
+
+const memoryContext = (s) => ({ agent: s.agent, cwd: s.cwd, transcriptPath: s.transcriptPath, home: os.homedir(), codexHome: CODEX_HOME });
+
+function carryFrom(s) {
+  const t = s?.transcriptPath && readTranscript(s.transcriptPath);
+  return t ? carriedContext({ agent: s.agent, cwd: s.cwd, title: s.title, messages: t.messages }) : '';
+}
+
 // ---------- hook events ----------
 
 function handleHook(p, res) {
@@ -1011,6 +1136,9 @@ function handleHook(p, res) {
 
 function snapshot() {
   return {
+    version: VERSION,
+    update: updateState(),
+    terminal: TERMINAL_ENABLED,
     settings,
     usage,
     codexUsage,
@@ -1020,14 +1148,18 @@ function snapshot() {
   };
 }
 
+const sendAll = (event, data) => {
+  const msg = `event: ${event}\ndata: ${JSON.stringify(data)}\n\n`;
+  for (const c of clients.keys()) c.write(msg);
+};
+
 let broadcastQueued = false;
 function broadcast() {
   if (broadcastQueued) return;
   broadcastQueued = true;
   setTimeout(() => {
     broadcastQueued = false;
-    const msg = `event: state\ndata: ${JSON.stringify(snapshot())}\n\n`;
-    for (const c of clients.keys()) c.write(msg);
+    sendAll('state', snapshot());
   }, 30);
 }
 
@@ -1115,6 +1247,7 @@ const server = http.createServer(async (req, res) => {
       clients.set(res, { id: url.searchParams.get('client') || '', focused: url.searchParams.get('focused') === '1' });
       onAttentionChanged();
       if (!usage || Date.now() - usage.fetchedAt > 60000) fetchUsage();
+      if (Date.now() - updateCheckedAt > UPDATE_THROTTLE_MS) checkForUpdate();
       const ping = setInterval(() => res.write(': ping\n\n'), 20000);
       req.on('close', () => {
         clearInterval(ping);
@@ -1141,6 +1274,12 @@ const server = http.createServer(async (req, res) => {
       return json(res, 200, { apps: await findApps(s.cwd), detects: process.platform === 'win32' });
     }
 
+    if (req.method === 'GET' && url.pathname === '/api/memory') {
+      const s = sessions.get(url.searchParams.get('session'));
+      if (!s) return json(res, 404, { error: 'unknown session' });
+      return json(res, 200, { files: readMemory(memoryContext(s)) });
+    }
+
     if (req.method === 'POST' && url.pathname.startsWith('/api/')) {
       const body = await readBody(req);
 
@@ -1148,7 +1287,44 @@ const server = http.createServer(async (req, res) => {
         stopServer();
         return json(res, 200, {});
       }
+      if (url.pathname === '/api/restart') {
+        stopServer({ restart: true });
+        return json(res, 200, {});
+      }
+      if (url.pathname === '/api/update') {
+        if (!TERMINAL_ENABLED) return json(res, 400, { error: 'Run agenter update in a terminal.' });
+        if (!updates.canSelfUpdate()) return json(res, 400, { error: 'This copy is a git clone. Update it with git pull.' });
+        const id = terminalId(os.homedir());
+        const term = terminals.open(id, os.homedir());
+        if (term.running) return json(res, 409, { error: 'That terminal is busy. Wait for it to finish, or press Stop.' });
+        const quote = (p) => `'${p.replace(/'/g, "''")}'`;
+        terminals.run(id, `& ${quote(process.execPath)} ${quote(path.join(__dirname, 'cli.js'))} update`, checkForUpdate);
+        return json(res, 200, { id });
+      }
+      if (url.pathname.startsWith('/api/terminal/')) {
+        if (!TERMINAL_ENABLED) return json(res, 400, { error: 'The terminal is turned off or not available here.' });
+        if (url.pathname === '/api/terminal/open') {
+          const cwd = sessions.get(body.sessionId)?.cwd;
+          const folder = cwd && fs.existsSync(cwd) ? cwd : os.homedir();
+          return json(res, 200, terminals.open(terminalId(folder), folder));
+        }
+        const ok = url.pathname === '/api/terminal/run' ? terminals.run(body.id, String(body.input ?? '')) : url.pathname === '/api/terminal/stop' && terminals.stop(body.id);
+        return json(res, ok ? 200 : 404, {});
+      }
+      if (url.pathname === '/api/pick-folder') {
+        return json(res, 200, await pickFolder(body.start));
+      }
+      if (url.pathname === '/api/memory/save') {
+        const s = sessions.get(body.sessionId);
+        if (!s) return json(res, 404, { error: 'unknown session' });
+        const { status, ...out } = saveMemory(memoryContext(s), body.path, body.text, body.mtime);
+        return json(res, status, out);
+      }
       if (url.pathname === '/api/respond') {
+        if (body.action === 'reply' && body.images?.length) {
+          if (!pending.has(body.id)) return json(res, 404, {});
+          body.message = withImages(body.message, saveImages(body.images));
+        }
         const s = sessions.get(pending.get(body.id)?.item.sessionId);
         const ok = respond(body.id, body.action, body);
         // Handing something back to VS Code: bring up that project's window so it's right there.
@@ -1169,16 +1345,19 @@ const server = http.createServer(async (req, res) => {
       }
       if (url.pathname === '/api/session/steer') {
         const s = sessions.get(body.sessionId);
-        const text = String(body.message || '').trim();
+        const hasImages = Array.isArray(body.images) && body.images.length > 0;
         // A closed Claude session can only be continued by Agenter; Codex queues for its app either way.
-        if (!s || !text || (s.agent !== 'codex' && driveOf(s) === 'vscode' && (s.status === 'dormant' || s.status === 'ended'))) return json(res, 404, {});
-        return json(res, 200, { result: await steer(s, text) });
+        if (!s || !(String(body.message || '').trim() || hasImages) || (s.agent !== 'codex' && driveOf(s) === 'vscode' && (s.status === 'dormant' || s.status === 'ended'))) return json(res, 404, {});
+        return json(res, 200, { result: await steer(s, withImages(body.message, saveImages(body.images))) });
       }
       if (url.pathname === '/api/session/new') {
         const cwd = String(body.cwd || '').trim().replace(/^"(.*)"$/, '$1');
-        const text = String(body.message || '').trim();
+        const typed = String(body.message || '').trim();
         const codex = body.agent === 'codex';
-        if (!text) return json(res, 400, { error: `Type a first message for ${codex ? 'Codex' : 'Claude'}.` });
+        if (!typed && !body.images?.length) return json(res, 400, { error: `Type a first message for ${codex ? 'Codex' : 'Claude'}.` });
+        const text = withImages(typed, saveImages(body.images));
+        const carried = carryFrom(sessions.get(body.fromSessionId));
+        const prompt = carried ? `${text}\n\n${carried}` : text;
         let isDir = false;
         try {
           isDir = path.isAbsolute(cwd) && fs.statSync(cwd).isDirectory();
@@ -1187,9 +1366,9 @@ const server = http.createServer(async (req, res) => {
         if (codex) {
           if (!findCodex()) return json(res, 400, { error: "Couldn't find Codex. Install the Codex VS Code extension, or set AGENTER_CODEX_BIN to codex.exe." });
           // Codex names the session itself, so it's registered once Codex has started it.
-          const draft = Object.assign(newSession(''), { agent: 'codex', title: text.split('\n')[0].slice(0, 140), lastEventAt: Date.now() });
+          const draft = Object.assign(newSession(''), { agent: 'codex', title: (typed || 'Image').split('\n')[0].slice(0, 140), lastEventAt: Date.now() });
           setCwd(draft, path.resolve(cwd));
-          const started = await Promise.race([startCodexRun(draft, text, { fresh: true }), new Promise((r) => setTimeout(() => r({ error: 'Codex took too long to start.' }), 60000))]);
+          const started = await Promise.race([startCodexRun(draft, prompt, { fresh: true }), new Promise((r) => setTimeout(() => r({ error: 'Codex took too long to start.' }), 60000))]);
           if (!started?.id) return json(res, 500, { error: `Codex couldn't start: ${started?.error || 'unknown error'}` });
           settings.drive = { ...settings.drive, [started.id]: 'agenter' };
           saveSettings();
@@ -1200,11 +1379,11 @@ const server = http.createServer(async (req, res) => {
         if (!findClaude()) return json(res, 400, { error: "Couldn't find Claude Code. Install the VS Code extension, or set AGENTER_CLAUDE to claude.exe." });
         const s = getOrCreateSession(crypto.randomUUID());
         setCwd(s, path.resolve(cwd));
-        s.title = text.split('\n')[0].slice(0, 140);
+        s.title = (typed || 'Image').split('\n')[0].slice(0, 140);
         s.lastEventAt = Date.now();
         settings.drive = { ...settings.drive, [s.id]: 'agenter' };
         saveSettings();
-        if (!startRun(s, text, { fresh: true })) {
+        if (!startRun(s, prompt, { fresh: true })) {
           sessions.delete(s.id);
           return json(res, 500, { error: "Couldn't start Claude." });
         }
@@ -1278,7 +1457,9 @@ const server = http.createServer(async (req, res) => {
 server.requestTimeout = 0; // hooks can legitimately wait a long time for you
 // Only listen when run directly; the tests load this file to drive the hook and steering logic.
 if (require.main === module) {
+  let portRetries = process.env.AGENTER_RESTART ? 50 : 0;
   server.on('error', (err) => {
+    if (err.code === 'EADDRINUSE' && portRetries-- > 0) return void setTimeout(() => server.listen(PORT, HOST), 200);
     if (err.code === 'EADDRINUSE') console.error(`Port ${PORT} is busy. Is Agenter already running? (Set AGENTER_PORT to use another port.)`);
     else console.error(err);
     process.exit(1);
@@ -1286,12 +1467,19 @@ if (require.main === module) {
   server.listen(PORT, HOST, () => {
     const url = `http://localhost:${PORT}`;
     console.log(`Agenter dashboard: ${url}`);
+    delete process.env.AGENTER_RESTART;
     fs.rmSync(STOPPED_FILE, { force: true });
+    // Shortcuts start us inside the install folder, and on Windows a folder that's in use
+    // can't be replaced by `npm i -g`. Everything here uses full paths.
+    process.chdir(os.homedir());
     startTray();
     startDiscovery();
+    pruneUploads();
     startCodexDiscovery();
     fetchUsage();
     setInterval(fetchUsage, USAGE_INTERVAL_MS);
+    checkForUpdate();
+    setInterval(checkForUpdate, UPDATE_INTERVAL_MS);
     if (!process.argv.includes('--no-open')) openDashboard(url);
   });
 }
@@ -1300,5 +1488,5 @@ module.exports = {
   sessions, pending, clients, runners, dismissed,
   get settings() { return settings; },
   handleHook, hold, respond, steer, takeQueue, touchSession, snapshot, driveOf, effectiveHold,
-  findClaude, findCodex, codexCommand, releaseRun,
+  findClaude, findCodex, codexCommand, releaseRun, saveImages, withImages, UPLOADS_DIR,
 };