@oddessentials/agent-guild 0.25.0 → 0.26.0

package/src/manager/github.mjs

@@ -101,6 +101,34 @@ export function localState(target, fullName) {
   }
 }
 
+/** The GitHub repository (lowercase owner/name) that `dir`, or the Git work tree holding it, has as its origin. */
+export function folderOrigin(dir) {
+  for (let current = path.resolve(dir); ; current = path.dirname(current)) {
+    const dotGit = path.join(current, '.git');
+    let stat = null;
+    try { stat = fs.statSync(dotGit); } catch { /* look further up */ }
+    if (stat) {
+      try {
+        return remoteRepo(originUrl(fs.readFileSync(path.join(commonGitDir(dotGit, stat), 'config'), 'utf8')));
+      } catch {
+        return null;
+      }
+    }
+    if (path.dirname(current) === current) return null;
+  }
+}
+
+/** A worktree's .git is a file naming its own Git folder, whose `commondir` names the folder holding the shared config. */
+function commonGitDir(dotGit, stat) {
+  if (stat.isDirectory()) return dotGit;
+  const named = /^gitdir:\s*(.+?)\s*$/m.exec(fs.readFileSync(dotGit, 'utf8'));
+  if (!named) throw new Error('no gitdir');
+  const gitDir = path.resolve(path.dirname(dotGit), named[1]);
+  let common = null;
+  try { common = fs.readFileSync(path.join(gitDir, 'commondir'), 'utf8').trim(); } catch { /* not a worktree */ }
+  return common ? path.resolve(gitDir, common) : gitDir;
+}
+
 /** Quote one word for the POSIX shell Git runs core.sshCommand with (Git for Windows ships one too). */
 export function shellQuote(word) {
   return `'${String(word).replaceAll('\'', '\'\\\'\'')}'`;
@@ -395,7 +423,7 @@ export class GitHub extends EventEmitter {
     if (!res.ok) {
       const body = await res.json().catch(() => null);
       const limited = (res.status === 403 || res.status === 429) && res.headers.get('x-ratelimit-remaining') === '0';
-      throw refusal(502, 'github_error', limited ? 'GitHub API rate limit exceeded; try again later' : `GitHub answered HTTP ${res.status}${body?.message ? `: ${body.message}` : ''}`, { github: res.status });
+      throw refusal(502, 'github_error', limited ? 'GitHub API rate limit exceeded; try again later' : `GitHub answered HTTP ${res.status}${body?.message ? `: ${body.message}` : ''}`, { github: res.status, limited });
     }
     return { body: await res.json(), res };
   }
@@ -613,6 +641,33 @@ export class GitHub extends EventEmitter {
     };
   }
 
+  /** Every signed-in account's repositories in one list. One account's failure does not hide the others'. */
+  async allRepos({ refresh = false } = {}) {
+    const settled = await Promise.all(this.accounts.map(async (account) => {
+      try {
+        return { account, page: await this.repos(account.id, { refresh }) };
+      } catch (err) {
+        return { account, err };
+      }
+    }));
+    const repos = [];
+    const errors = [];
+    let truncated = false;
+    let oldest = null;
+    for (const { account, page, err } of settled) {
+      if (err) {
+        errors.push({ accountId: account.id, login: account.login, code: err.code || 'github_error', message: err.status ? err.message : 'Could not list repositories' });
+        continue;
+      }
+      truncated ||= page.truncated;
+      const at = Date.parse(page.fetchedAt);
+      if (oldest === null || at < oldest) oldest = at;
+      for (const { target, local, ...repo } of page.repos) repos.push({ accountId: account.id, login: account.login, ...repo });
+    }
+    repos.sort((a, b) => (Date.parse(b.pushedAt) || 0) - (Date.parse(a.pushedAt) || 0) || a.fullName.localeCompare(b.fullName) || a.accountId - b.accountId);
+    return { repos, truncated, errors, fetchedAt: oldest === null ? null : new Date(oldest).toISOString() };
+  }
+
   async _loadRepos(account) {
     const seen = new Map();
     let url = '/user/repos?per_page=100&sort=pushed&affiliation=owner,collaborator,organization_member';

package/src/manager/main.mjs

@@ -12,7 +12,7 @@ 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 { createManagerServer, parseAllowedHosts } from './server.mjs';
 import { SelfUpdate } from './self-update.mjs';
 import { resolveBaseEnv, pathReader } from './shell-env.mjs';
 import { writeReportShims } from './report-shims.mjs';
@@ -39,6 +39,8 @@ const VERSION_REFRESH_MS = 60 * 60 * 1000;
 
 /** `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 = {} } = {}) {
+  // Validate before creating files, processes or timers, so a typo fails startup cleanly.
+  const extraHosts = parseAllowedHosts(process.env.AGENT_GUILD_ALLOWED_HOSTS);
   ensureDataDir();
   const token = loadOrCreateToken();
   const baseEnv = resolveBaseEnv();
@@ -133,6 +135,7 @@ export async function startManager({ port = resolvePort(), host = DEFAULT_HOST,
     webDir,
     version,
     selfUpdate,
+    extraHosts,
     extraOrigins,
     launcher: launcherPath(),
     onShutdownRequest: ({ restart = false } = {}) => shutdown('requested via API', { restart }).then(() => process.exit(0)),

package/src/manager/server.mjs

@@ -4,9 +4,14 @@
 import http from 'node:http';
 import fs from 'node:fs';
 import path from 'node:path';
+import { isIP } from 'node:net';
 import { createRequire } from 'node:module';
 import { WebSocketServer } from 'ws';
 import { timingSafeEqualString } from './session-manager.mjs';
+import { folderOrigin } from './github.mjs';
+import { createViews } from './github-views.mjs';
+import { createFolderOpener } from './folder-opener.mjs';
+import { createFolderPicker } from './folder-picker.mjs';
 
 const require = createRequire(import.meta.url);
 const API = '/api/v1';
@@ -57,15 +62,19 @@ class HttpError extends Error {
   }
 }
 
-function sendJson(res, status, body) {
-  const payload = JSON.stringify(body);
-  res.writeHead(status, {
-    ...SECURITY_HEADERS,
-    'Content-Type': 'application/json; charset=utf-8',
-    'Cache-Control': 'no-store',
-    'Content-Length': Buffer.byteLength(payload),
-  });
-  res.end(payload);
+/** Exact Host authorities, also safe to include as CSP WebSocket sources. */
+export function parseAllowedHosts(value = '') {
+  const entries = value.split(',').map((entry) => entry.trim().toLowerCase()).filter(Boolean);
+  for (const entry of entries) {
+    const match = /^(\[[0-9a-f:.]+\]|[a-z0-9.-]+)(?::([1-9]\d{0,4}))?$/.exec(entry);
+    const name = match?.[1];
+    const validName = name?.startsWith('[') ? isIP(name.slice(1, -1)) === 6
+      : name && name.length <= 253 && name.split('.').every((label) => /^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/.test(label));
+    if (!validName || (match[2] && Number(match[2]) > 65535)) {
+      throw new Error(`Invalid AGENT_GUILD_ALLOWED_HOSTS entry ${JSON.stringify(entry)}. Use a hostname with an optional port, such as guild.example.ts.net or guild.example.ts.net:8443; URLs and wildcards are not allowed.`);
+    }
+  }
+  return [...new Set(entries)];
 }
 
 function readJsonBody(req) {
@@ -115,18 +124,28 @@ export function createManagerServer({
   webDir,
   version = '0.0.0',
   selfUpdate = null,
+  extraHosts = [],
   extraOrigins = [],
+  folderOpener = createFolderOpener({ resolveCwd: (cwd) => manager.resolveCwd(cwd) }),
+  folderPicker = createFolderPicker({ resolveCwd: (cwd) => manager.resolveCwd(cwd) }),
   /** The double-click launcher file for this platform, or null when the package carries none. */
   launcher = null,
   /** @type {(opts: { restart: boolean }) => void} */
   onShutdownRequest = () => {},
 }) {
+  const proxyHosts = parseAllowedHosts(extraHosts.join(','));
+  const socketSources = proxyHosts.flatMap((authority) => [`ws://${authority}`, `wss://${authority}`]);
+  const securityHeaders = {
+    ...SECURITY_HEADERS,
+    'Content-Security-Policy': SECURITY_HEADERS['Content-Security-Policy'].replace(
+      "connect-src 'self'", ["connect-src 'self'", ...socketSources].join(' ')),
+  };
   const upgradeInfo = () => (selfUpdate ? selfUpdate.describe() : null);
   const startedAt = new Date().toISOString();
   const vendor = vendorFiles();
   let boundPort = port;
 
-  const allowedHosts = () => new Set([`127.0.0.1:${boundPort}`, `localhost:${boundPort}`, `[::1]:${boundPort}`]);
+  const allowedHosts = () => new Set([`127.0.0.1:${boundPort}`, `localhost:${boundPort}`, `[::1]:${boundPort}`, ...proxyHosts]);
   const allowedOrigins = () =>
     new Set([`http://127.0.0.1:${boundPort}`, `http://localhost:${boundPort}`, `http://[::1]:${boundPort}`, ...extraOrigins]);
 
@@ -154,13 +173,24 @@ export function createManagerServer({
     }
   }
 
+  function sendJson(res, status, body) {
+    const payload = JSON.stringify(body);
+    res.writeHead(status, {
+      ...securityHeaders,
+      'Content-Type': 'application/json; charset=utf-8',
+      'Cache-Control': 'no-store',
+      'Content-Length': Buffer.byteLength(payload),
+    });
+    res.end(payload);
+  }
+
   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,
+        ...securityHeaders,
         'Content-Type': MIME[path.extname(file).toLowerCase()] || 'application/octet-stream',
         'Cache-Control': cache ? 'public, max-age=3600' : 'no-cache',
         ETag: etag,
@@ -239,8 +269,21 @@ export function createManagerServer({
         warnings: registry.warnings,
         upgrade: upgradeInfo(),
         launcher,
+        folderOpener: folderOpener.describe(),
+        folderPicker: folderPicker.describe(),
       });
     }
+    if (route === '/open-folder' && method === 'POST') {
+      const { cwd } = await readJsonBody(req);
+      await folderOpener.open(cwd);
+      return sendJson(res, 200, { ok: true });
+    }
+    if (route === '/pick-folder' && method === 'POST') {
+      const { cwd } = await readJsonBody(req);
+      const gone = new AbortController();
+      res.once('close', () => gone.abort());
+      return sendJson(res, 200, { path: await folderPicker.pick(cwd, { signal: gone.signal }) });
+    }
     if (route === '/upgrade' && method === 'POST') {
       const session = await manager.upgrade();
       return sendJson(res, 201, { session: session.toJSON() });
@@ -362,6 +405,8 @@ export function createManagerServer({
     throw new HttpError(404, `no route for ${method} ${url.pathname}`, 'not_found');
   }
 
+  const views = github ? createViews(github) : null;
+
   async function handleGitHub(req, res, url, route, method) {
     const snapshot = () => ({ github: github.snapshot() });
     if (route === '/github' && method === 'GET') return sendJson(res, 200, snapshot());
@@ -378,6 +423,30 @@ export function createManagerServer({
       const session = manager.clone({ account: body.account, repo: body.repo, parent: body.parent });
       return sendJson(res, 201, { session: session.toJSON() });
     }
+    if (route === '/github/repos' && method === 'GET') {
+      return sendJson(res, 200, await github.allRepos({ refresh: url.searchParams.get('refresh') === '1' }));
+    }
+    if (route === '/github/origin' && method === 'GET') {
+      const folder = manager.resolveCwd(url.searchParams.get('cwd'));
+      return sendJson(res, 200, { folder, repo: folderOrigin(folder) });
+    }
+    const view = route.match(/^\/github\/accounts\/([^/]+)\/repos\/([^/]+)\/([^/]+)\/(issues|actions|pulls)(?:\/([^/]+))?$/);
+    if (view) {
+      let parts;
+      try { parts = view.map((part) => (part === undefined ? part : decodeURIComponent(part))); } catch { throw new HttpError(400, 'repo must be a GitHub repository written as owner/name', 'bad_repo'); }
+      const [, id, owner, name, kind, number] = parts;
+      if (kind === 'issues' && number === undefined && method === 'GET') {
+        return sendJson(res, 200, await views.issues(id, owner, name, { state: url.searchParams.get('state') || 'open' }));
+      }
+      if (kind === 'issues' && number === undefined && method === 'POST') {
+        return sendJson(res, 201, { issue: await views.createIssue(id, owner, name, await readJsonBody(req)) });
+      }
+      if (kind === 'issues' && number !== undefined && method === 'PATCH') {
+        return sendJson(res, 200, { issue: await views.updateIssue(id, owner, name, number, await readJsonBody(req)) });
+      }
+      if (kind === 'actions' && number === undefined && method === 'GET') return sendJson(res, 200, await views.actions(id, owner, name));
+      if (kind === 'pulls' && number === undefined && method === 'GET') return sendJson(res, 200, await views.pulls(id, owner, name));
+    }
     const match = route.match(/^\/github\/accounts\/([^/]+)(\/repos|\/ssh)?$/);
     if (match) {
       const [, id, action] = match;
@@ -462,7 +531,7 @@ export function createManagerServer({
 
   function handleEvents(ws) {
     eventClients.add(ws);
-    safeSend(ws, { type: 'hello', version, pid: process.pid, startedAt, launcher, upgrade: upgradeInfo(), sessions: manager.list() });
+    safeSend(ws, { type: 'hello', version, pid: process.pid, startedAt, launcher, folderOpener: folderOpener.describe(), folderPicker: folderPicker.describe(), upgrade: upgradeInfo(), sessions: manager.list() });
     ws.on('close', () => eventClients.delete(ws));
     ws.on('message', () => { /* events socket is server -> client only */ });
   }

package/web/activity-favicon.js

@@ -0,0 +1,71 @@
+// The favicon mirrors the card label, including providers that stay active.
+export const isSessionWorking = (session) => session.status !== 'exited' && session.activity === 'active';
+
+const FRAME_MS = 100;
+const FRAME_COUNT = 24;
+
+/** One cached animation per page. Browser throttling may leave any frame visible. */
+export function createActivityFavicon({
+  link, reducedMotion, document = globalThis.document, Image = globalThis.Image,
+  setTimer = setTimeout, clearTimer = clearTimeout, now = () => performance.now(),
+}) {
+  const original = link?.href;
+  let frames = [], timer = null, working = false, paused = false, started = 0;
+
+  function paint() {
+    clearTimer(timer);
+    timer = null;
+    if (!link) return;
+    const animate = working && !paused && !reducedMotion.matches && frames.length > 0;
+    const frame = animate ? Math.floor((now() - started) / FRAME_MS) % frames.length : 0;
+    const href = working && frames.length ? frames[frame] : original;
+    if (link.href !== href) link.href = href;
+    if (animate) timer = setTimer(paint, FRAME_MS);
+  }
+
+  if (link) {
+    const image = new Image();
+    image.onload = () => {
+      try {
+        const canvas = document.createElement('canvas');
+        canvas.width = canvas.height = 32;
+        const ctx = canvas.getContext('2d');
+        if (!ctx) return;
+        // Encode once, not on every tick. Every frame has a distinct working ring.
+        frames = Array.from({ length: FRAME_COUNT }, (_, index) => {
+          ctx.clearRect(0, 0, 32, 32);
+          ctx.drawImage(image, 5, 5, 22, 22);
+          ctx.lineWidth = 3;
+          ctx.strokeStyle = '#164e3b';
+          ctx.beginPath();
+          ctx.arc(16, 16, 14, 0, Math.PI * 2);
+          ctx.stroke();
+          ctx.strokeStyle = '#4ade80';
+          ctx.lineCap = 'round';
+          ctx.beginPath();
+          const angle = index * Math.PI * 2 / FRAME_COUNT - Math.PI / 2;
+          ctx.arc(16, 16, 14, angle, angle + Math.PI / 2);
+          ctx.stroke();
+          return canvas.toDataURL('image/png');
+        });
+        paint();
+      } catch { /* An optional indicator must never prevent the cards from rendering. */ }
+    };
+    image.onerror = () => {}; // Retain the original favicon if the asset cannot load.
+    image.src = original;
+  }
+  reducedMotion.addEventListener('change', paint);
+
+  return {
+    setWorking(value) {
+      if (working === value) return;
+      working = value;
+      if (working) started = now();
+      paint();
+    },
+    setPaused(value) {
+      paused = value;
+      paint();
+    },
+  };
+}