@oddessentials/agent-guild 0.25.0 → 0.27.0

package/src/manager/folder-opener.mjs

@@ -0,0 +1,96 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { spawn } from 'node:child_process';
+
+const failure = (status, code, message) => Object.assign(new Error(message), { status, code });
+const isFile = (file) => { try { return fs.statSync(file).isFile(); } catch { return false; } };
+
+export function folderOpenTarget({ platform = process.platform, env = process.env, release = os.release(), fileExists = isFile } = {}) {
+  const onPath = (name) => (env.PATH || '').split(':').filter((dir) => path.posix.isAbsolute(dir))
+    .map((dir) => path.posix.join(dir, name)).find(fileExists);
+  let command, kind, label, reason;
+  if (platform === 'win32') {
+    kind = 'explorer';
+    label = 'File Explorer';
+    command = path.win32.join(env.SystemRoot || env.WINDIR || 'C:\\Windows', 'explorer.exe');
+  } else if (platform === 'darwin') {
+    kind = 'finder';
+    label = 'Finder';
+    command = '/usr/bin/open';
+  } else if (platform === 'linux' && (env.WSL_DISTRO_NAME || /microsoft|wsl/i.test(release))) {
+    kind = 'explorer';
+    label = 'File Explorer';
+    command = onPath('explorer.exe');
+    reason = 'Windows Explorer is unavailable. Enable Windows interoperability in WSL to open folders.';
+  } else if (platform === 'linux') {
+    kind = 'desktop';
+    label = 'file manager';
+    if (env.DISPLAY || env.WAYLAND_DISPLAY) {
+      command = onPath('xdg-open');
+      reason = 'Install xdg-utils and configure a default file manager to open folders.';
+    } else reason = 'Opening folders requires a desktop session on the computer running Agent Guild.';
+  } else reason = 'Opening folders is unavailable on this operating system.';
+  const available = Boolean(command && fileExists(command));
+  return { command, kind, label: label || 'file manager', available, reason: available ? null : reason || `${label} is unavailable on the computer running Agent Guild.` };
+}
+
+export function createFolderOpener({ resolveCwd, spawnImpl = spawn, cooldownMs = 1000, handoffMs = 1500, ...targetOptions }) {
+  let pending = false, nextOpen = 0;
+  return {
+    describe() {
+      const { available, label, reason } = folderOpenTarget(targetOptions);
+      return { available, label, reason };
+    },
+    async open(cwd) {
+      if (cwd !== undefined && (typeof cwd !== 'string' || /[\0\r\n]/.test(cwd))) {
+        throw failure(400, 'bad_cwd', 'The working folder must be a directory path.');
+      }
+      if (typeof cwd === 'string' && /^[a-z][a-z\d+.-]*:\/\//i.test(cwd.trim()) && !/^[a-z]:[/\\]/i.test(cwd.trim())) {
+        throw failure(400, 'bad_cwd', 'Enter a folder path, not a URL.');
+      }
+      if (pending || Date.now() < nextOpen) throw failure(429, 'folder_open_busy', 'Please wait before opening another folder.');
+      const target = folderOpenTarget(targetOptions);
+      if (!target.available) throw failure(409, 'folder_open_unavailable', target.reason);
+      pending = true;
+      try {
+        const resolved = resolveCwd(cwd);
+        let dir;
+        try {
+          dir = await fs.promises.realpath(resolved);
+          if (!(await fs.promises.stat(dir)).isDirectory()) throw new Error();
+        } catch {
+          throw failure(400, 'bad_cwd', 'The working folder does not exist or cannot be accessed.');
+        }
+        let args;
+        if (target.kind === 'explorer') args = ['.'];
+        else if (target.kind === 'finder') {
+          // Reveal packages instead of asking Finder to open (and potentially execute) them.
+          args = /\.(app|bundle|framework|plugin|kext|prefpane|workflow)$/i.test(dir)
+            ? ['-R', dir] : ['-a', '/System/Library/CoreServices/Finder.app', dir];
+        } else args = [dir];
+        nextOpen = Date.now() + cooldownMs;
+        await new Promise((resolve, reject) => {
+          let child, timer, settled = false;
+          const finish = (error) => {
+            if (settled) return;
+            settled = true;
+            clearTimeout(timer);
+            child?.unref();
+            if (error) reject(failure(409, 'folder_open_failed', `Could not open ${target.label}. Check that a desktop session and file manager are available on the computer running Agent Guild.`));
+            else resolve();
+          };
+          try {
+            child = spawnImpl(target.command, args, {
+              cwd: target.kind === 'explorer' ? dir : undefined,
+              shell: false, windowsHide: true, detached: true, stdio: 'ignore',
+            });
+            child.once('error', finish);
+            child.once('spawn', () => { timer = setTimeout(() => finish(), handoffMs); });
+            child.once('exit', (code) => finish(code !== 0 && !(target.kind === 'explorer' && code === 1)));
+          } catch (error) { finish(error); }
+        });
+      } finally { pending = false; }
+    },
+  };
+}

package/src/manager/folder-picker.mjs

@@ -0,0 +1,116 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { spawn } from 'node:child_process';
+
+const TITLE = 'Choose a working folder';
+const failure = (status, code, message) => Object.assign(new Error(message), { status, code });
+const isFile = (file) => { try { return fs.statSync(file).isFile(); } catch { return false; } };
+const isFolder = (dir) => { try { return fs.statSync(dir).isDirectory(); } catch { return false; } };
+
+const APPLESCRIPT = [
+  'on run argv',
+  'activate',
+  'try',
+  `return POSIX path of (choose folder with prompt "${TITLE}" default location (POSIX file (item 1 of argv)))`,
+  'on error number -128',
+  'return ""',
+  'end try',
+  'end run',
+];
+
+let windowsScript;
+function encodedWindowsScript() {
+  windowsScript ??= Buffer.from(fs.readFileSync(new URL('./folder-picker.ps1', import.meta.url), 'utf8'), 'utf16le').toString('base64');
+  return windowsScript;
+}
+
+export function folderPickTarget({ platform = process.platform, env = process.env, release = os.release(), fileExists = isFile } = {}) {
+  const onPath = (name) => (env.PATH || '').split(':').filter((dir) => path.posix.isAbsolute(dir))
+    .map((dir) => path.posix.join(dir, name)).find(fileExists);
+  let command, kind, translate, reason;
+  if (platform === 'win32') {
+    kind = 'windows';
+    command = path.win32.join(env.SystemRoot || env.WINDIR || 'C:\\Windows', 'System32', 'WindowsPowerShell', 'v1.0', 'powershell.exe');
+  } else if (platform === 'darwin') {
+    kind = 'mac';
+    command = '/usr/bin/osascript';
+  } else if (platform === 'linux' && (env.WSL_DISTRO_NAME || /microsoft|wsl/i.test(release))) {
+    kind = 'windows';
+    translate = onPath('wslpath');
+    command = translate && onPath('powershell.exe');
+    reason = 'Windows PowerShell is unavailable. Enable Windows interoperability in WSL to choose folders.';
+  } else if (platform === 'linux') {
+    if (env.DISPLAY || env.WAYLAND_DISPLAY) {
+      command = onPath('zenity');
+      kind = command ? 'zenity' : 'kdialog';
+      command ||= onPath('kdialog');
+      reason = 'Install zenity or kdialog to choose folders.';
+    } else reason = 'Choosing folders requires a desktop session on the computer running Agent Guild.';
+  } else reason = 'Choosing folders is unavailable on this operating system.';
+  const available = Boolean(command && fileExists(command));
+  return { command, kind, translate, available, reason: available ? null : reason || 'The folder dialog is unavailable on the computer running Agent Guild.' };
+}
+
+export function createFolderPicker({ resolveCwd, spawnImpl = spawn, env = process.env, ...targetOptions }) {
+  let pending = false;
+
+  const run = (command, args, { signal, env: childEnv = env } = {}) => new Promise((resolve, reject) => {
+    let child, out = '';
+    try {
+      child = spawnImpl(command, args, { env: childEnv, shell: false, windowsHide: true, stdio: ['ignore', 'pipe', 'ignore'] });
+    } catch (error) { return reject(error); }
+    const stop = () => child.kill();
+    if (signal?.aborted) stop();
+    else signal?.addEventListener('abort', stop, { once: true });
+    child.stdout.setEncoding('utf8').on('data', (chunk) => { out += chunk; });
+    child.once('error', reject);
+    child.once('close', (code) => {
+      signal?.removeEventListener('abort', stop);
+      resolve({ code, out: out.replace(/[\r\n]+$/, '') });
+    });
+  });
+
+  function dialog(target, start, signal) {
+    if (target.kind === 'windows') {
+      const vars = { AGENT_GUILD_PICK_START: start, AGENT_GUILD_PICK_TITLE: TITLE };
+      if (target.translate) vars.WSLENV = [env.WSLENV, 'AGENT_GUILD_PICK_START/p', 'AGENT_GUILD_PICK_TITLE'].filter(Boolean).join(':');
+      return run(target.command, ['-NoLogo', '-NoProfile', '-NonInteractive', '-ExecutionPolicy', 'Bypass', '-EncodedCommand', encodedWindowsScript()], { signal, env: { ...env, ...vars } });
+    }
+    if (target.kind === 'mac') return run(target.command, [...APPLESCRIPT.flatMap((line) => ['-e', line]), start], { signal });
+    if (target.kind === 'zenity') return run(target.command, ['--file-selection', '--directory', `--title=${TITLE}`, `--filename=${path.join(start, path.sep)}`], { signal });
+    return run(target.command, ['--title', TITLE, '--getexistingdirectory', start], { signal });
+  }
+
+  return {
+    describe() {
+      const { available, reason } = folderPickTarget({ env, ...targetOptions });
+      return { available, reason };
+    },
+    async pick(cwd, { signal } = {}) {
+      if (cwd !== undefined && (typeof cwd !== 'string' || /[\0\r\n]/.test(cwd))) {
+        throw failure(400, 'bad_cwd', 'The working folder must be a directory path.');
+      }
+      if (pending) throw failure(409, 'folder_pick_busy', 'A folder dialog is already open on the computer running Agent Guild.');
+      const target = folderPickTarget({ env, ...targetOptions });
+      if (!target.available) throw failure(409, 'folder_pick_unavailable', target.reason);
+      let start;
+      try { start = resolveCwd(cwd); } catch { start = os.homedir(); }
+      pending = true;
+      try {
+        const broken = () => failure(409, 'folder_pick_failed', 'Could not show the folder dialog. Check that a desktop session is available on the computer running Agent Guild.');
+        let result = await dialog(target, start, signal).catch(() => { throw broken(); });
+        const cancelled = result.code === 0 || (result.code === 1 && target.kind !== 'windows' && target.kind !== 'mac');
+        if (signal?.aborted || (!result.out && cancelled)) return null;
+        if (result.code !== 0) throw broken();
+        if (target.translate) {
+          result = await run(target.translate, ['-u', result.out], { signal }).catch(() => ({ code: 1 }));
+          if (result.code !== 0) throw failure(409, 'folder_pick_failed', 'The chosen folder cannot be reached from WSL.');
+        }
+        const dir = path.resolve(result.out);
+        if (!isFolder(dir)) throw failure(409, 'folder_pick_failed', 'The chosen folder cannot be used as a working folder.');
+        return dir;
+      } finally { pending = false; }
+    },
+  };
+}

package/src/manager/folder-picker.ps1

@@ -0,0 +1,84 @@
+$ErrorActionPreference = 'Stop'
+[Console]::OutputEncoding = New-Object System.Text.UTF8Encoding $false
+Add-Type -AssemblyName System.Windows.Forms
+Add-Type -ReferencedAssemblies System.Windows.Forms -TypeDefinition @'
+using System;
+using System.Runtime.InteropServices;
+using System.Windows.Forms;
+public static class GuildFolderPicker {
+  [ComImport, Guid("DC1C5A9C-E88A-4dde-A5A1-60F82A20AEF7")] class FileOpenDialog {}
+  [ComImport, Guid("42f85136-db7e-439c-85f1-e4075d135fc8"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+  interface IFileDialog {
+    [PreserveSig] int Show(IntPtr owner);
+    void SetFileTypes(uint count, IntPtr specs);
+    void SetFileTypeIndex(uint index);
+    void GetFileTypeIndex(out uint index);
+    void Advise(IntPtr events, out uint cookie);
+    void Unadvise(uint cookie);
+    void SetOptions(uint options);
+    void GetOptions(out uint options);
+    void SetDefaultFolder(IShellItem item);
+    void SetFolder(IShellItem item);
+    void GetFolder(out IShellItem item);
+    void GetCurrentSelection(out IShellItem item);
+    void SetFileName([MarshalAs(UnmanagedType.LPWStr)] string name);
+    void GetFileName([MarshalAs(UnmanagedType.LPWStr)] out string name);
+    void SetTitle([MarshalAs(UnmanagedType.LPWStr)] string title);
+    void SetOkButtonLabel([MarshalAs(UnmanagedType.LPWStr)] string text);
+    void SetFileNameLabel([MarshalAs(UnmanagedType.LPWStr)] string text);
+    void GetResult(out IShellItem item);
+  }
+  [ComImport, Guid("43826D1E-E718-42EE-BC55-A1E261C37BFE"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+  interface IShellItem {
+    void BindToHandler(IntPtr context, ref Guid handler, ref Guid iid, out IntPtr result);
+    void GetParent(out IShellItem parent);
+    void GetDisplayName(uint form, [MarshalAs(UnmanagedType.LPWStr)] out string name);
+  }
+  [StructLayout(LayoutKind.Sequential)] struct RECT { public int L, T, R, B; }
+  [DllImport("shell32.dll", CharSet = CharSet.Unicode, PreserveSig = false)]
+  static extern void SHCreateItemFromParsingName(string path, IntPtr context, ref Guid iid, out IShellItem item);
+  [DllImport("user32.dll")] static extern bool GetWindowRect(IntPtr window, out RECT rect);
+  [DllImport("user32.dll")] static extern IntPtr GetForegroundWindow();
+  [DllImport("user32.dll")] static extern uint GetWindowThreadProcessId(IntPtr window, IntPtr process);
+  [DllImport("kernel32.dll")] static extern uint GetCurrentThreadId();
+  [DllImport("user32.dll")] static extern bool AttachThreadInput(uint from, uint to, bool attach);
+  [DllImport("user32.dll")] static extern bool SetForegroundWindow(IntPtr window);
+
+  public static string Pick(string start, string title) {
+    var dialog = (IFileDialog)new FileOpenDialog();
+    uint options;
+    dialog.GetOptions(out options);
+    dialog.SetOptions(options | 0x20 | 0x40 | 0x800);
+    dialog.SetTitle(title);
+    if (!string.IsNullOrEmpty(start)) {
+      try {
+        IShellItem folder;
+        Guid iid = typeof(IShellItem).GUID;
+        SHCreateItemFromParsingName(start, IntPtr.Zero, ref iid, out folder);
+        dialog.SetFolder(folder);
+      } catch {}
+    }
+    // A dialog from a background process opens behind the browser. An invisible owner that takes
+    // the foreground brings it to the front, just inside the window that asked.
+    using (var owner = new Form { TopMost = true, ShowInTaskbar = false, FormBorderStyle = FormBorderStyle.None, Opacity = 0, StartPosition = FormStartPosition.Manual }) {
+      IntPtr asking = GetForegroundWindow();
+      RECT r;
+      if (GetWindowRect(asking, out r)) owner.SetBounds(r.L + 48, r.T + 48, 1, 1);
+      else owner.StartPosition = FormStartPosition.CenterScreen;
+      owner.Show();
+      uint front = GetWindowThreadProcessId(asking, IntPtr.Zero), self = GetCurrentThreadId();
+      AttachThreadInput(self, front, true);
+      SetForegroundWindow(owner.Handle);
+      AttachThreadInput(self, front, false);
+      if (dialog.Show(owner.Handle) != 0) return null;
+    }
+    IShellItem picked;
+    dialog.GetResult(out picked);
+    string path;
+    picked.GetDisplayName(0x80058000, out path);
+    return path;
+  }
+}
+'@
+$picked = [GuildFolderPicker]::Pick($env:AGENT_GUILD_PICK_START, $env:AGENT_GUILD_PICK_TITLE)
+if ($picked) { [Console]::Out.Write($picked) }

package/src/manager/github-views.mjs

@@ -0,0 +1,171 @@
+// Issues, Actions runs and open pull requests of one repository, read with a
+// signed-in account. Reading and editing stay shallow: GitHub's page is the full view.
+
+import { nextLink, parseRepo } from './github.mjs';
+
+const PAGE = 30;
+const RUNNING = new Set(['queued', 'in_progress', 'waiting', 'requested', 'pending']);
+const WEB = 'https://github.com';
+const ISSUE_RE = /^[1-9]\d{0,9}$/;
+
+function refusal(status, code, message) {
+  return Object.assign(new Error(message), { status, code });
+}
+
+/** A github.com page, or the fallback built from checked parts. */
+export function githubUrl(value, fallback) {
+  try {
+    const url = new URL(value);
+    if (url.protocol === 'https:' && url.hostname === 'github.com') return url.href;
+  } catch { /* the fallback */ }
+  return fallback;
+}
+
+function text(value, max) {
+  return typeof value === 'string' ? value.slice(0, max) : '';
+}
+
+function time(value) {
+  return Number.isFinite(Date.parse(value)) ? new Date(value).toISOString() : null;
+}
+
+function loginOf(user) {
+  return typeof user?.login === 'string' && user.login.trim() ? user.login.trim().slice(0, 80) : 'unknown';
+}
+
+function cleanIssue(raw, fullName) {
+  const number = raw?.number;
+  if (!raw || typeof raw !== 'object' || !Number.isSafeInteger(number) || number < 1) return null;
+  if (typeof raw.title !== 'string' || !raw.title.trim()) return null;
+  return {
+    number,
+    title: raw.title.trim().slice(0, 256),
+    body: text(raw.body, 65536),
+    state: raw.state === 'closed' ? 'closed' : 'open',
+    user: loginOf(raw.user),
+    comments: Number.isSafeInteger(raw.comments) ? raw.comments : 0,
+    updatedAt: time(raw.updated_at),
+    url: githubUrl(raw.html_url, `${WEB}/${fullName}/issues/${number}`),
+  };
+}
+
+function cleanRun(raw, fullName) {
+  const id = raw?.id;
+  if (!raw || typeof raw !== 'object' || !Number.isSafeInteger(id) || id < 1) return null;
+  return {
+    id,
+    name: text(raw.name, 200) || text(raw.display_title, 200) || 'Workflow',
+    title: text(raw.display_title, 300) || text(raw.name, 300) || 'Workflow run',
+    branch: text(raw.head_branch, 200),
+    event: text(raw.event, 40),
+    status: typeof raw.status === 'string' ? raw.status.slice(0, 40) : 'unknown',
+    conclusion: typeof raw.conclusion === 'string' ? raw.conclusion.slice(0, 40) : null,
+    runNumber: Number.isSafeInteger(raw.run_number) ? raw.run_number : null,
+    updatedAt: time(raw.updated_at),
+    url: githubUrl(raw.html_url, `${WEB}/${fullName}/actions/runs/${id}`),
+  };
+}
+
+function cleanPull(raw, fullName) {
+  const number = raw?.number;
+  if (!raw || typeof raw !== 'object' || !Number.isSafeInteger(number) || number < 1) return null;
+  if (typeof raw.title !== 'string' || !raw.title.trim()) return null;
+  return {
+    number,
+    title: raw.title.trim().slice(0, 256),
+    draft: raw.draft === true,
+    user: loginOf(raw.user),
+    head: text(raw.head?.ref, 200),
+    base: text(raw.base?.ref, 200),
+    updatedAt: time(raw.updated_at),
+    url: githubUrl(raw.html_url, `${WEB}/${fullName}/pull/${number}`),
+  };
+}
+
+function checkTitle(title) {
+  if (typeof title !== 'string' || !title.trim()) throw refusal(400, 'bad_title', 'title must be a non-empty string');
+  if (title.trim().length > 256) throw refusal(400, 'bad_title', 'Keep the title to 256 characters or fewer.');
+  return title.trim();
+}
+
+function checkBody(body) {
+  if (body === undefined || body === null) return '';
+  if (typeof body !== 'string') throw refusal(400, 'bad_body', 'body must be a string');
+  if (body.length > 48000) throw refusal(400, 'bad_body', 'Keep the description to 48,000 characters or fewer, or edit it on GitHub.');
+  return body;
+}
+
+export function createViews(github) {
+  /** One request for the repository's account. GitHub's own refusals become answers the page can show as they are. */
+  async function call(accountId, owner, name, route, init) {
+    const account = github.account(accountId);
+    const repo = parseRepo(`${owner ?? ''}/${name ?? ''}`);
+    try {
+      const { body, res } = await github._apiJson(account, `/repos/${repo.owner}/${repo.name}${route}`, init);
+      return { body, res, repo };
+    } catch (err) {
+      if (err.limited) throw refusal(429, 'rate_limited', err.message);
+      if (err.github === 404) throw refusal(404, 'not_found', `GitHub could not find ${repo.fullName} for @${account.login}`);
+      if (err.github === 410) throw refusal(404, 'issues_disabled', `Issues are turned off for ${repo.fullName}`);
+      if (err.github === 403) throw refusal(403, 'forbidden', `GitHub did not let @${account.login} do that in ${repo.fullName}`);
+      if (err.github === 422) throw refusal(400, 'github_rejected', err.message);
+      throw err;
+    }
+  }
+
+  return {
+    async issues(accountId, owner, name, { state = 'open' } = {}) {
+      if (state !== 'open' && state !== 'closed' && state !== 'all') throw refusal(400, 'bad_state', 'state must be open, closed or all');
+      const { body, res, repo } = await call(accountId, owner, name, `/issues?state=${state}&per_page=${PAGE}&sort=updated&direction=desc`);
+      return {
+        issues: (Array.isArray(body) ? body : []).filter((item) => item && !item.pull_request).map((item) => cleanIssue(item, repo.fullName)).filter(Boolean),
+        truncated: Boolean(nextLink(res.headers.get('link'))),
+        url: `${WEB}/${repo.fullName}/issues`,
+      };
+    },
+
+    async createIssue(accountId, owner, name, { title, body } = {}) {
+      const payload = { title: checkTitle(title), body: checkBody(body) };
+      const { body: created, repo } = await call(accountId, owner, name, '/issues', { method: 'POST', body: JSON.stringify(payload) });
+      const issue = cleanIssue(created, repo.fullName);
+      if (!issue) throw refusal(502, 'github_error', 'GitHub did not describe the new issue');
+      return issue;
+    },
+
+    async updateIssue(accountId, owner, name, number, patch = {}) {
+      if (!ISSUE_RE.test(String(number ?? ''))) throw refusal(400, 'bad_issue', 'issue number must be a positive integer');
+      const payload = {};
+      if (patch.title !== undefined) payload.title = checkTitle(patch.title);
+      if (patch.body !== undefined) payload.body = checkBody(patch.body);
+      if (patch.state !== undefined) {
+        if (patch.state !== 'open' && patch.state !== 'closed') throw refusal(400, 'bad_state', 'state must be open or closed');
+        payload.state = patch.state;
+      }
+      if (Object.keys(payload).length === 0) throw refusal(400, 'bad_request', 'nothing to update');
+      const { body, repo } = await call(accountId, owner, name, `/issues/${Number(number)}`, { method: 'PATCH', body: JSON.stringify(payload) });
+      const issue = cleanIssue(body, repo.fullName);
+      if (!issue) throw refusal(502, 'github_error', 'GitHub did not describe the issue');
+      return issue;
+    },
+
+    async actions(accountId, owner, name) {
+      const { body, res, repo } = await call(accountId, owner, name, `/actions/runs?per_page=${PAGE}`);
+      const runs = (Array.isArray(body?.workflow_runs) ? body.workflow_runs : []).map((item) => cleanRun(item, repo.fullName)).filter(Boolean);
+      return {
+        runs,
+        running: runs.some((run) => RUNNING.has(run.status)),
+        truncated: Boolean(nextLink(res.headers.get('link'))),
+        url: `${WEB}/${repo.fullName}/actions`,
+      };
+    },
+
+    async pulls(accountId, owner, name) {
+      const { body, res, repo } = await call(accountId, owner, name, `/pulls?state=open&per_page=${PAGE}&sort=updated&direction=desc`);
+      return {
+        pulls: (Array.isArray(body) ? body : []).map((item) => cleanPull(item, repo.fullName)).filter(Boolean),
+        truncated: Boolean(nextLink(res.headers.get('link'))),
+        url: `${WEB}/${repo.fullName}/pulls`,
+      };
+    },
+  };
+}

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

@@ -13,6 +13,7 @@ import { NewsFeed } from './news.mjs';
 import { Changelog } from './changelog.mjs';
 import { GitHub } from './github.mjs';
 import { createManagerServer } from './server.mjs';
+import { RemoteAccess, loadRemoteAccess } from './remote-access.mjs';
 import { SelfUpdate } from './self-update.mjs';
 import { resolveBaseEnv, pathReader } from './shell-env.mjs';
 import { writeReportShims } from './report-shims.mjs';
@@ -38,10 +39,13 @@ const rootDir = path.resolve(here, '../..');
 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 = {} } = {}) {
+export async function startManager({ port = resolvePort(), host = DEFAULT_HOST, sessionDefaults, version = VERSION, packageFile = PACKAGE_FILE, github: githubOptions = {}, remoteAccess: remoteOptions = {} } = {}) {
+  // Validate before creating files, processes or timers, so a typo fails startup cleanly.
+  const remoteSettings = loadRemoteAccess(paths.remoteAccess);
   ensureDataDir();
   const token = loadOrCreateToken();
   const baseEnv = resolveBaseEnv();
+  const remoteAccess = new RemoteAccess({ file: paths.remoteAccess, env: baseEnv, loaded: remoteSettings, ...remoteOptions });
   const webDir = path.join(rootDir, 'web');
   // The hooks in examples/ call `agent-guild-report` by name; these shims
   // make that name resolve inside every session. Regenerated at each start
@@ -93,6 +97,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);
+    remoteAccess.close();
     github.close();
     removeRuntimeFile();
     // Sessions end before the API closes, and the last event says whether
@@ -115,9 +120,6 @@ export async function startManager({ port = resolvePort(), host = DEFAULT_HOST,
     return closing;
   };
 
-  const extraOrigins = (process.env.AGENT_GUILD_ALLOWED_ORIGINS || '')
-    .split(',').map((s) => s.trim()).filter(Boolean);
-
   api = createManagerServer({
     manager,
     registry,
@@ -133,10 +135,13 @@ export async function startManager({ port = resolvePort(), host = DEFAULT_HOST,
     webDir,
     version,
     selfUpdate,
-    extraOrigins,
+    extraHosts: remoteSettings.config.access.hosts,
+    extraOrigins: remoteSettings.config.access.origins,
+    remoteAccess,
     launcher: launcherPath(),
     onShutdownRequest: ({ restart = false } = {}) => shutdown('requested via API', { restart }).then(() => process.exit(0)),
   });
+  remoteAccess.attach({ apply: (access) => api.setAccessPolicy(access), getTarget: () => api.url });
 
   try {
     await api.listen();
@@ -162,7 +167,7 @@ export async function startManager({ port = resolvePort(), host = DEFAULT_HOST,
   });
   console.log(`[manager] Agent Guild ${version} listening on ${api.url} (pid ${process.pid})`);
   refreshVersions();
-  return { api, manager, registry, token, shutdown };
+  return { api, manager, registry, token, shutdown, remoteAccess };
 }
 
 function isEntryPoint() {