@oddessentials/agent-guild 0.6.0 → 0.7.1

package/src/manager/main.mjs

@@ -11,6 +11,7 @@ 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';
@@ -34,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();
@@ -60,7 +61,8 @@ 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 });
@@ -84,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
@@ -116,6 +119,7 @@ export async function startManager({ port = resolvePort(), host = DEFAULT_HOST,
     modelStats,
     news,
     changelog,
+    github,
     token,
     host,
     port,

package/src/manager/server.mjs

@@ -107,6 +107,7 @@ export function createManagerServer({
   modelStats,
   news = null,
   changelog = null,
+  github = null,
   token,
   host = '127.0.0.1',
   port = 0,
@@ -259,6 +260,7 @@ export function createManagerServer({
     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]);
@@ -328,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 {
@@ -341,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 });
       }
     }
@@ -383,6 +425,7 @@ export function createManagerServer({
   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,