@oddessentials/agent-guild 0.5.0 → 0.6.0

package/README.md

@@ -44,7 +44,7 @@ coding tool, and see at a glance which sessions and agents are working.
   can watch. Sessions keep running; once they are done, **Restart to use
   vX.Y.Z** in the top bar switches to the new version.
 * **Light or dark.** The page follows your system theme and the top-bar
-  toggle switches it. The guild artwork is the dark theme.
+  toggle switches it.
 
 ## Requirements
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oddessentials/agent-guild",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "Launch and watch AI coding-assistant terminal sessions from one local web page. A bundled session manager owns the terminals so the page can close and reconnect.",
   "license": "MIT",
   "repository": {

package/src/manager/changelog.mjs

@@ -0,0 +1,195 @@
+import { EventEmitter } from 'node:events';
+import { compareVersions } from './versions.mjs';
+import { FeedError, USER_AGENT, decodeEntities, failure, readBody, refusal, webUrl } from './news.mjs';
+
+const REPOSITORY = 'oddessentials/agent-guild';
+const RELEASES_URL = `https://github.com/${REPOSITORY}/releases`;
+const API_URL = `https://api.github.com/repos/${REPOSITORY}/releases?per_page=30`;
+const TTL_MS = 60 * 60 * 1000;
+const RETRY_MS = 10 * 60 * 1000;
+const MISSING_MS = 2 * 60 * 1000;
+const FETCH_TIMEOUT_MS = 20000;
+const MAX_BYTES = 5 * 1024 * 1024;
+const MAX_CHANGES = 100;
+const MAX_NOTES = 20000;
+const MAX_LINE = 1000;
+const RELEASE_TAG = /^v?(\d+\.\d+\.\d+)$/;
+const VERSION_HEADING = /^v?\d+\.\d+\.\d+(?![\d.])/;
+const INSTALL_STEPS = /^install or update$/i;
+const COMMIT_LINK = /\s*\(\[[0-9a-f]{7,40}\]\([^)\s]*\)\)/gi;
+const INLINE = /\*\*(.+?)\*\*|`([^`]+)`|!\[[^\]]*\]\([^)]*\)|<(https?:\/\/[^>\s]+)>|\[([^\]]+)\]\(([^)\s]+)\)|<\/?[a-z][^>]*>/gi;
+
+const iso = (time) => (time ? new Date(time).toISOString() : null);
+
+function textRun(text, strong) {
+  return strong ? { text: decodeEntities(text), strong: true } : { text: decodeEntities(text) };
+}
+
+function inline(source, strong = false) {
+  const runs = [];
+  let at = 0;
+  for (const match of source.matchAll(INLINE)) {
+    if (match.index > at) runs.push(textRun(source.slice(at, match.index), strong));
+    const [, bold, code, autolink, label, href] = match;
+    if (bold !== undefined) {
+      runs.push(...inline(bold, true));
+    } else if (code !== undefined) {
+      runs.push({ ...(strong && { strong: true }), text: code, code: true });
+    } else if (autolink !== undefined || label !== undefined) {
+      const url = webUrl(autolink ?? href);
+      runs.push({ ...textRun(label ?? autolink, strong), ...(url && { url }) });
+    }
+    at = match.index + match[0].length;
+  }
+  if (at < source.length) runs.push(textRun(source.slice(at), strong));
+  return runs;
+}
+
+const sameStyle = (a, b) => !a.url && !b.url && Boolean(a.code) === Boolean(b.code) && Boolean(a.strong) === Boolean(b.strong);
+
+function tidy(runs) {
+  const tidied = [];
+  for (const run of runs) {
+    const text = run.text.replace(/[\u0000-\u001f\u007f]/g, ' ').replace(/\s+/g, ' ');
+    if (!text) continue;
+    const last = tidied.at(-1);
+    if (last && sameStyle(last, run)) last.text += text;
+    else tidied.push({ ...run, text });
+  }
+  if (tidied.length) {
+    tidied[0].text = tidied[0].text.trimStart();
+    tidied.at(-1).text = tidied.at(-1).text.trimEnd();
+  }
+  return tidied.filter((run) => run.text);
+}
+
+function plain(source) {
+  return tidy(inline(source)).map((run) => run.text).join('');
+}
+
+export function parseNotes(markdown) {
+  const sections = [];
+  let section = null;
+  let change = null;
+  let skipping = false;
+  let fenced = false;
+  let count = 0;
+  for (const whole of String(markdown ?? '').slice(0, MAX_NOTES).replace(/<!--[\s\S]*?(?:-->|$)/g, '').split(/\r?\n/)) {
+    const line = whole.slice(0, MAX_LINE);
+    if (/^\s*(?:```|~~~)/.test(line)) {
+      fenced = !fenced;
+      change = null;
+      continue;
+    }
+    if (fenced) continue;
+    const heading = /^\s{0,3}#{1,6}\s+(.*?)(?:\s+#+)?\s*$/.exec(line);
+    if (heading) {
+      const title = plain(heading[1]);
+      change = null;
+      section = null;
+      skipping = INSTALL_STEPS.test(title);
+      if (title && !skipping && !VERSION_HEADING.test(title)) sections.push(section = { title, changes: [] });
+      continue;
+    }
+    if (skipping) continue;
+    if (/^\s*([-*_])(?:\s*\1){2,}\s*$/.test(line)) {
+      change = null;
+      continue;
+    }
+    const bullet = /^\s*(?:[-*+]|\d{1,9}[.)])\s+(.*)$/.exec(line);
+    const body = (bullet ? bullet[1] : line.replace(/^\s*(?:>\s?)+/, '')).trim();
+    if (!body) {
+      change = null;
+      continue;
+    }
+    const runs = tidy(inline(body.replace(COMMIT_LINK, '')));
+    if (runs.length === 0) continue;
+    if (!bullet && change) {
+      change.splice(0, change.length, ...tidy([...change, { text: ' ' }, ...runs]));
+      continue;
+    }
+    if (count === MAX_CHANGES) break;
+    if (!section) sections.push(section = { title: null, changes: [] });
+    section.changes.push(change = runs);
+    count++;
+  }
+  return sections.filter((s) => s.changes.length > 0);
+}
+
+export function parseReleases(json) {
+  const list = JSON.parse(json);
+  if (!Array.isArray(list)) throw new FeedError('sent no releases');
+  const releases = new Map();
+  for (const release of list) {
+    if (!release || typeof release !== 'object' || release.draft || release.prerelease) continue;
+    const tag = String(release.tag_name ?? '');
+    const version = RELEASE_TAG.exec(tag)?.[1];
+    if (!version || releases.has(version)) continue;
+    const published = Date.parse(release.published_at);
+    releases.set(version, {
+      version,
+      url: webUrl(String(release.html_url ?? '')) ?? `${RELEASES_URL}/tag/${encodeURIComponent(tag)}`,
+      publishedAt: Number.isFinite(published) ? new Date(published).toISOString() : null,
+      sections: parseNotes(typeof release.body === 'string' ? release.body : ''),
+    });
+  }
+  return [...releases.values()].sort((a, b) => compareVersions(b.version, a.version));
+}
+
+export class Changelog extends EventEmitter {
+  constructor({
+    latest = () => null, fetchImpl = fetch, url = API_URL,
+    ttlMs = TTL_MS, retryMs = RETRY_MS, missingMs = MISSING_MS, timeoutMs = FETCH_TIMEOUT_MS, maxBytes = MAX_BYTES,
+  } = {}) {
+    super();
+    this.latest = latest;
+    this.fetchImpl = fetchImpl;
+    this.url = url;
+    this.ttlMs = ttlMs;
+    this.retryMs = retryMs;
+    this.missingMs = missingMs;
+    this.timeoutMs = timeoutMs;
+    this.maxBytes = maxBytes;
+    this.releases = [];
+    this.etag = null;
+    this.checkedAt = 0;
+    this.okAt = 0;
+    this.error = null;
+    this.refreshing = null;
+  }
+
+  snapshot() {
+    this._refreshDue();
+    return { refreshing: Boolean(this.refreshing), okAt: iso(this.okAt), error: this.error, releases: this.releases };
+  }
+
+  _refreshDue() {
+    if (this.refreshing) return;
+    const latest = this.latest();
+    const missing = Boolean(latest) && !this.releases.some((release) => release.version === latest);
+    const wait = this.error ? this.retryMs : missing ? this.missingMs : this.ttlMs;
+    if (Date.now() - this.checkedAt < wait) return;
+    this.refreshing = this._refresh().finally(() => {
+      this.refreshing = null;
+      this.emit('updated');
+    });
+  }
+
+  async _refresh() {
+    this.checkedAt = Date.now();
+    try {
+      const headers = { 'User-Agent': USER_AGENT, Accept: 'application/vnd.github+json', 'X-GitHub-Api-Version': '2022-11-28' };
+      if (this.etag) headers['If-None-Match'] = this.etag;
+      const res = await this.fetchImpl(this.url, { headers, signal: AbortSignal.timeout(this.timeoutMs) });
+      if (res.status !== 304) {
+        if (!res.ok) throw new FeedError(refusal(res));
+        this.releases = parseReleases(await readBody(res, this.maxBytes));
+        this.etag = res.headers.get('etag');
+      }
+      this.error = null;
+      this.okAt = Date.now();
+    } catch (err) {
+      this.error = failure(err, this.timeoutMs);
+    }
+  }
+}

package/src/manager/main.mjs

@@ -10,6 +10,7 @@ import { UsageMonitor } from './usage.mjs';
 import { SessionHistory } from './session-history.mjs';
 import { ModelStats } from './model-stats.mjs';
 import { NewsFeed } from './news.mjs';
+import { Changelog } from './changelog.mjs';
 import { createManagerServer } from './server.mjs';
 import { SelfUpdate } from './self-update.mjs';
 import { resolveBaseEnv, pathReader } from './shell-env.mjs';
@@ -64,6 +65,7 @@ export async function startManager({ port = resolvePort(), host = DEFAULT_HOST,
   const history = new SessionHistory({ registry, env: baseEnv });
   const modelStats = new ModelStats({ registry });
   const news = new NewsFeed({ registry });
+  const changelog = new Changelog({ latest: () => selfUpdate.latest });
   let closing = null;
 
   const refreshVersions = () => {
@@ -113,6 +115,7 @@ export async function startManager({ port = resolvePort(), host = DEFAULT_HOST,
     history,
     modelStats,
     news,
+    changelog,
     token,
     host,
     port,

package/src/manager/news.mjs

@@ -14,7 +14,7 @@ const LIMITS = { news: 20, releases: 5, research: 10 };
 const TITLE_MAX = 300;
 const SUMMARY_MAX = 240;
 const RAW_MAX = 8000;
-const USER_AGENT = `agent-guild/${VERSION} (+https://github.com/oddessentials/agent-guild)`;
+export const USER_AGENT = `agent-guild/${VERSION} (+https://github.com/oddessentials/agent-guild)`;
 const FEED_ACCEPT = 'application/rss+xml, application/atom+xml, application/xml;q=0.9, text/xml;q=0.8, */*;q=0.5';
 
 const latestRelease = (id, name, repo, provider) => ({
@@ -64,7 +64,7 @@ const NAMED = {
   uacute: 'ú', uuml: 'ü', ccedil: 'ç', ntilde: 'ñ', szlig: 'ß', Auml: 'Ä', Ouml: 'Ö', Uuml: 'Ü',
 };
 
-class FeedError extends Error {}
+export class FeedError extends Error {}
 
 const fields = new Map();
 const attrs = new Map();
@@ -329,7 +329,7 @@ function merge(previous, fresh, limit, now) {
   return [...byKey.values()].sort((a, b) => b.time - a.time).slice(0, limit);
 }
 
-async function readBody(res, maxBytes) {
+export async function readBody(res, maxBytes) {
   const tooLarge = () => new FeedError(`sent more than ${maxBytes / 1024 / 1024} MB`);
   if (Number(res.headers.get('content-length')) > maxBytes) throw tooLarge();
   const chunks = [];
@@ -349,12 +349,12 @@ async function readBody(res, maxBytes) {
   }
 }
 
-function refusal(res) {
+export function refusal(res) {
   if ((res.status === 403 || res.status === 429) && res.headers.get('x-ratelimit-remaining') === '0') return 'GitHub API rate limit exceeded';
   return `HTTP ${res.status}`;
 }
 
-function failure(err, timeoutMs) {
+export function failure(err, timeoutMs) {
   if (err instanceof FeedError) return err.message;
   if (err?.name === 'TimeoutError') return `did not answer within ${timeoutMs / 1000} seconds`;
   if (err instanceof SyntaxError) return 'sent data that could not be read';

package/src/manager/server.mjs

@@ -21,6 +21,9 @@ const MIME = {
   '.css': 'text/css; charset=utf-8',
   '.svg': 'image/svg+xml',
   '.png': 'image/png',
+  '.avif': 'image/avif',
+  '.webp': 'image/webp',
+  '.woff2': 'font/woff2',
   '.ico': 'image/x-icon',
   '.json': 'application/json; charset=utf-8',
 };
@@ -103,6 +106,7 @@ export function createManagerServer({
   history,
   modelStats,
   news = null,
+  changelog = null,
   token,
   host = '127.0.0.1',
   port = 0,
@@ -148,16 +152,27 @@ export function createManagerServer({
     }
   }
 
-  function serveFile(res, file, { cache = false } = {}) {
-    fs.readFile(file, (err, data) => {
-      if (err) return sendJson(res, 404, { error: { code: 'not_found', message: 'not found' } });
-      res.writeHead(200, {
+  function serveFile(req, res, file, { cache = false } = {}) {
+    const notFound = () => sendJson(res, 404, { error: { code: 'not_found', message: 'not found' } });
+    fs.stat(file, (statErr, stat) => {
+      if (statErr || !stat.isFile()) return notFound();
+      const etag = `W/"${stat.size.toString(16)}-${Math.floor(stat.mtimeMs).toString(16)}"`;
+      const headers = {
         ...SECURITY_HEADERS,
         'Content-Type': MIME[path.extname(file).toLowerCase()] || 'application/octet-stream',
         'Cache-Control': cache ? 'public, max-age=3600' : 'no-cache',
-        'Content-Length': data.length,
+        ETag: etag,
+      };
+      const known = String(req.headers['if-none-match'] || '').split(',').map((tag) => tag.trim());
+      if (known.includes(etag) || known.includes('*')) {
+        res.writeHead(304, headers);
+        return res.end();
+      }
+      fs.readFile(file, (err, data) => {
+        if (err) return notFound();
+        res.writeHead(200, { ...headers, 'Content-Length': data.length });
+        res.end(data);
       });
-      res.end(data);
     });
   }
 
@@ -165,7 +180,7 @@ export function createManagerServer({
     if (req.method !== 'GET' && req.method !== 'HEAD') {
       throw new HttpError(405, 'method not allowed', 'method_not_allowed');
     }
-    if (vendor[pathname]) return serveFile(res, vendor[pathname], { cache: true });
+    if (vendor[pathname]) return serveFile(req, res, vendor[pathname], { cache: true });
     let rel;
     try {
       rel = pathname === '/' ? 'index.html' : decodeURIComponent(pathname).replace(/^\/+/, '');
@@ -177,7 +192,7 @@ export function createManagerServer({
     if (file !== webDir && !file.startsWith(webDir + path.sep)) {
       throw new HttpError(404, 'not found', 'not_found');
     }
-    return serveFile(res, file);
+    return serveFile(req, res, file);
   }
 
   async function handleApi(req, res, url) {
@@ -241,6 +256,9 @@ export function createManagerServer({
     if (route === '/news' && method === 'GET' && news) {
       return sendJson(res, 200, news.snapshot());
     }
+    if (route === '/changelog' && method === 'GET' && changelog) {
+      return sendJson(res, 200, changelog.snapshot());
+    }
     const historyMatch = route.match(/^\/providers\/([a-z0-9][a-z0-9_-]{0,31})\/history$/);
     if (historyMatch && method === 'GET') {
       const provider = registry.get(historyMatch[1]);
@@ -364,6 +382,7 @@ export function createManagerServer({
   registry.on('updated', () => broadcast({ type: 'providers.updated', providers: registry.list() }));
   selfUpdate?.on('updated', () => broadcast({ type: 'manager.upgrade', upgrade: upgradeInfo() }));
   news?.on('updated', () => broadcast({ type: 'news.updated' }));
+  changelog?.on('updated', () => broadcast({ type: 'changelog.updated' }));
 
   function handleEvents(ws) {
     eventClients.add(ws);