@oddessentials/agent-guild 0.5.0 → 0.7.0

package/src/manager/main.mjs

@@ -10,6 +10,8 @@ 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 { GitHub } from './github.mjs';
 import { createManagerServer } from './server.mjs';
 import { SelfUpdate } from './self-update.mjs';
 import { resolveBaseEnv, pathReader } from './shell-env.mjs';
@@ -33,8 +35,8 @@ const rootDir = path.resolve(here, '../..');
 
 const VERSION_REFRESH_MS = 60 * 60 * 1000;
 
-/** `version` and `packageFile` stand in for the real ones in tests. */
-export async function startManager({ port = resolvePort(), host = DEFAULT_HOST, sessionDefaults, version = VERSION, packageFile = PACKAGE_FILE } = {}) {
+/** `version`, `packageFile` and `github` (GitHub's URLs and client id) stand in for the real ones in tests. */
+export async function startManager({ port = resolvePort(), host = DEFAULT_HOST, sessionDefaults, version = VERSION, packageFile = PACKAGE_FILE, github: githubOptions = {} } = {}) {
   ensureDataDir();
   const token = loadOrCreateToken();
   const baseEnv = resolveBaseEnv();
@@ -59,11 +61,13 @@ export async function startManager({ port = resolvePort(), host = DEFAULT_HOST,
 
   let api;
   const selfUpdate = new SelfUpdate({ pkg: PACKAGE_NAME, version, packageFile, registry });
-  const manager = new SessionManager({ registry, baseEnv, getApiUrl: () => api.url, sessionDefaults, shimDir, selfUpdate });
+  const github = new GitHub({ dir: paths.github, registry, ...githubOptions });
+  const manager = new SessionManager({ registry, baseEnv, getApiUrl: () => api.url, sessionDefaults, shimDir, selfUpdate, github });
   const usage = new UsageMonitor({ registry, env: baseEnv });
   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 = () => {
@@ -82,6 +86,7 @@ export async function startManager({ port = resolvePort(), host = DEFAULT_HOST,
     if (closing) return closing;
     console.log(`[manager] ${restart ? 'restarting' : 'stopping'} (${reason}); ending ${manager.sessions.size} session(s)`);
     clearInterval(versionTimer);
+    github.close();
     removeRuntimeFile();
     // Sessions end before the API closes, and the last event says whether
     // every process confirmed its exit, so a client can tell a clean stop
@@ -113,6 +118,8 @@ export async function startManager({ port = resolvePort(), host = DEFAULT_HOST,
     history,
     modelStats,
     news,
+    changelog,
+    github,
     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,8 @@ export function createManagerServer({
   history,
   modelStats,
   news = null,
+  changelog = null,
+  github = null,
   token,
   host = '127.0.0.1',
   port = 0,
@@ -148,16 +153,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 +181,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 +193,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 +257,10 @@ 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());
+    }
+    if (route.startsWith('/github') && github) return handleGitHub(req, res, url, route, method);
     const historyMatch = route.match(/^\/providers\/([a-z0-9][a-z0-9_-]{0,31})\/history$/);
     if (historyMatch && method === 'GET') {
       const provider = registry.get(historyMatch[1]);
@@ -310,6 +330,45 @@ export function createManagerServer({
     throw new HttpError(404, `no route for ${method} ${url.pathname}`, 'not_found');
   }
 
+  async function handleGitHub(req, res, url, route, method) {
+    const snapshot = () => ({ github: github.snapshot() });
+    if (route === '/github' && method === 'GET') return sendJson(res, 200, snapshot());
+    if (route === '/github/sign-in' && method === 'POST') {
+      await github.startSignIn();
+      return sendJson(res, 202, snapshot());
+    }
+    if (route === '/github/sign-in' && method === 'DELETE') {
+      github.cancelSignIn();
+      return sendJson(res, 200, snapshot());
+    }
+    if (route === '/github/clone' && method === 'POST') {
+      const body = await readJsonBody(req);
+      const session = manager.clone({ account: body.account, repo: body.repo, parent: body.parent });
+      return sendJson(res, 201, { session: session.toJSON() });
+    }
+    const match = route.match(/^\/github\/accounts\/([^/]+)(\/repos|\/ssh)?$/);
+    if (match) {
+      const [, id, action] = match;
+      if (!action && method === 'DELETE') {
+        github.signOut(id);
+        return sendJson(res, 200, snapshot());
+      }
+      if (action === '/repos' && method === 'POST') {
+        const body = await readJsonBody(req);
+        return sendJson(res, 201, { repo: await github.createRepo(id, body) });
+      }
+      if (action === '/repos' && method === 'GET') {
+        const raw = url.searchParams.get('parent');
+        const parent = raw && raw.trim() ? manager.resolveCwd(raw) : null;
+        return sendJson(res, 200, { repos: await github.repos(id, { parent, refresh: url.searchParams.get('refresh') === '1' }) });
+      }
+      if (action === '/ssh' && method === 'POST') {
+        return sendJson(res, 200, { account: await github.setupSsh(id) });
+      }
+    }
+    throw new HttpError(404, `no route for ${method} ${url.pathname}`, 'not_found');
+  }
+
   const server = http.createServer(async (req, res) => {
     let url;
     try {
@@ -323,6 +382,7 @@ export function createManagerServer({
       if (!res.headersSent) {
         const error = { code: err.code || 'error', message: err.message };
         if (err.running !== undefined) error.running = err.running;
+        if (err.target !== undefined) error.target = err.target;
         sendJson(res, status, { error });
       }
     }
@@ -364,6 +424,8 @@ 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' }));
+  github?.on('updated', () => broadcast({ type: 'github.updated' }));
 
   function handleEvents(ws) {
     eventClients.add(ws);

package/src/manager/session-manager.mjs

@@ -11,6 +11,7 @@ import { Session, newId, clampDimension, cleanName } from './session.mjs';
 import { prependPath } from './report-shims.mjs';
 import { CHANNEL_LABELS } from './install-channels.mjs';
 import { SELF_PROVIDER } from './self-update.mjs';
+import { GITHUB_PROVIDER, dropsFromCloneEnv, parseRepo } from './github.mjs';
 
 export const MAX_SESSIONS = 32;
 const examplesDir = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../../examples');
@@ -50,8 +51,9 @@ export class SessionManager extends EventEmitter {
    * @param {object} [opts.sessionDefaults] passed through to Session
    * @param {string|null} [opts.shimDir]  folder with the agent-guild-report launchers, put first on PATH
    * @param {import('./self-update.mjs').SelfUpdate|null} [opts.selfUpdate]  the manager's own upgrade
+   * @param {import('./github.mjs').GitHub|null} [opts.github]
    */
-  constructor({ registry, baseEnv, getApiUrl, sessionDefaults = {}, shimDir = null, selfUpdate = null }) {
+  constructor({ registry, baseEnv, getApiUrl, sessionDefaults = {}, shimDir = null, selfUpdate = null, github = null }) {
     super();
     this.registry = registry;
     this.baseEnv = baseEnv;
@@ -59,6 +61,7 @@ export class SessionManager extends EventEmitter {
     this.sessionDefaults = sessionDefaults;
     this.shimDir = shimDir;
     this.selfUpdate = selfUpdate;
+    this.github = github;
     this.sessions = new Map();
     /** Removed sessions whose process has not exited yet. */
     this.exiting = new Set();
@@ -191,6 +194,26 @@ export class SessionManager extends EventEmitter {
     return session;
   }
 
+  /** Clone a GitHub repository into a folder under `parent`, in a visible session. */
+  clone({ account, repo, parent } = {}) {
+    if (!this.github) throw httpError(400, 'this manager has no GitHub integration', 'github_unavailable');
+    if (this.closing) throw httpError(503, 'the session manager is stopping', 'manager_stopping');
+    if (parent === undefined || parent === null || String(parent).trim() === '') throw httpError(400, 'parent must name the folder to clone into', 'bad_cwd');
+    const dir = this.resolveCwd(parent);
+    const target = path.join(dir, parseRepo(repo).name);
+    for (const s of this.sessions.values()) {
+      if (s.status === 'running' && s.task === 'clone' && s.clone?.path === target) {
+        throw httpError(409, `${s.clone.repo} is already being cloned into ${target}`, 'clone_in_progress');
+      }
+    }
+    const spec = this.github.cloneSpec({ accountId: account, repo, parent: dir });
+    return this._spawn({
+      provider: GITHUB_PROVIDER, description: GITHUB_PROVIDER, spawnSpec: spec.spawnSpec, cwd: dir,
+      name: `Clone ${spec.fullName}`, task: 'clone', extraEnv: spec.env, dropEnv: dropsFromCloneEnv,
+      clone: { repo: spec.fullName, path: spec.target, accountId: spec.account.id },
+    });
+  }
+
   runningFor(providerId) {
     let n = 0;
     for (const s of this.sessions.values()) if (s.status === 'running' && s.task === null && s.provider.id === providerId) n++;
@@ -204,7 +227,10 @@ export class SessionManager extends EventEmitter {
     return n;
   }
 
-  _spawn({ provider, description = this.registry.describe(provider), spawnSpec, cwd, cols, rows, name, resume = null, task = null, installKind = null, account = null }) {
+  _spawn({
+    provider, description = this.registry.describe(provider), spawnSpec, cwd, cols, rows, name, resume = null, task = null, installKind = null, account = null,
+    extraEnv = null, dropEnv = null, clone = null,
+  }) {
     if (this.closing) throw httpError(503, 'the session manager is stopping', 'manager_stopping');
     if (this.sessions.size >= MAX_SESSIONS) {
       throw httpError(429, `session limit reached (${MAX_SESSIONS}); remove finished sessions first`, 'too_many_sessions');
@@ -214,7 +240,7 @@ export class SessionManager extends EventEmitter {
 
     // The tool's hooks run `agent-guild-report` by name, so the launchers
     // go first on PATH, after any provider PATH override.
-    const env = prependPath(mergeEnv([this.baseEnv, provider.env, account?.env, {
+    let env = prependPath(mergeEnv([this.baseEnv, provider.env, account?.env, {
       TERM: 'xterm-256color',
       COLORTERM: 'truecolor',
       AGENT_GUILD_SESSION_ID: id,
@@ -228,6 +254,8 @@ export class SessionManager extends EventEmitter {
     // agent-team panes in that tmux window, outside the page, and tools
     // would tune their output to a terminal program that is not there.
     for (const key of ['TMUX', 'TMUX_PANE', 'STY', 'TERM_PROGRAM', 'TERM_PROGRAM_VERSION', 'ZELLIJ', 'ZELLIJ_SESSION_NAME', 'ZELLIJ_PANE_ID']) delete env[key];
+    if (dropEnv) for (const key of Object.keys(env)) if (dropEnv(key)) delete env[key];
+    if (extraEnv) env = mergeEnv([env, extraEnv]);
 
     let session;
     try {
@@ -245,6 +273,7 @@ export class SessionManager extends EventEmitter {
         resume,
         task,
         account: account ? { id: account.id, label: account.label } : null,
+        clone,
       });
     } catch (err) {
       throw httpError(500, `could not start ${provider.tool}: ${err.message}`, 'spawn_failed');

package/src/manager/session.mjs

@@ -55,8 +55,9 @@ export class Session extends EventEmitter {
    * @param {number} opts.rows
    * @param {string} [opts.name]
    * @param {string|null} [opts.resume]  id of the tool's own session being resumed
-   * @param {string|null} [opts.task]    "install" for a package install, "upgrade" for the manager's own, else null
+   * @param {string|null} [opts.task]    "install" for a package install, "upgrade" for the manager's own, "clone" for a GitHub clone, else null
    * @param {{id: string, label: string}|null} [opts.account]  the tool sign-in the session runs under
+   * @param {{repo: string, path: string, accountId: number}|null} [opts.clone]  what a clone session clones, and where
    * @param {string} opts.reportToken
    * @param {number} [opts.scrollback]
    * @param {number} [opts.activityIdleMs]
@@ -71,6 +72,7 @@ export class Session extends EventEmitter {
     this.resume = opts.resume ?? null;
     this.task = opts.task ?? null;
     this.account = opts.account ?? null;
+    this.clone = opts.clone ?? null;
     this.cwd = opts.cwd;
     this.cols = opts.cols;
     this.rows = opts.rows;
@@ -523,6 +525,7 @@ export class Session extends EventEmitter {
       resume: this.resume,
       task: this.task,
       account: this.account,
+      clone: this.clone,
       pid: this.pid,
       status: this.status,
       exitCode: this.exitCode,