agent-relay 1.2.3 → 1.3.1

package/dist/daemon/connection.js

@@ -23,11 +23,14 @@ export class Connection {
     config;
     _state = 'CONNECTING';
     _agentName;
+    _entityType;
     _cli;
     _program;
     _model;
     _task;
     _workingDirectory;
+    _displayName;
+    _avatarUrl;
     _sessionId;
     _resumeToken;
     _isResumed = false;
@@ -58,6 +61,9 @@ export class Connection {
     get agentName() {
         return this._agentName;
     }
+    get entityType() {
+        return this._entityType;
+    }
     get cli() {
         return this._cli;
     }
@@ -73,6 +79,12 @@ export class Connection {
     get workingDirectory() {
         return this._workingDirectory;
     }
+    get displayName() {
+        return this._displayName;
+    }
+    get avatarUrl() {
+        return this._avatarUrl;
+    }
     get sessionId() {
         return this._sessionId;
     }
@@ -133,11 +145,14 @@ export class Connection {
             return;
         }
         this._agentName = envelope.payload.agent;
+        this._entityType = envelope.payload.entityType;
         this._cli = envelope.payload.cli;
         this._program = envelope.payload.program;
         this._model = envelope.payload.model;
         this._task = envelope.payload.task;
         this._workingDirectory = envelope.payload.workingDirectory;
+        this._displayName = envelope.payload.displayName;
+        this._avatarUrl = envelope.payload.avatarUrl;
         // Check for session resume
         const resumeToken = envelope.payload.session?.resume_token;
         if (resumeToken) {

package/dist/daemon/orchestrator.d.ts

@@ -26,6 +26,8 @@ export declare class Orchestrator extends EventEmitter {
     private sessions;
     private supervisor;
     private workspacesFile;
+    private clientAlive;
+    private pingInterval?;
     constructor(config?: Partial<OrchestratorConfig>);
     /**
      * Start the orchestrator

package/dist/daemon/orchestrator.js

@@ -39,6 +39,9 @@ export class Orchestrator extends EventEmitter {
         contextPersistence: { enabled: true, autoInjectOnRestart: true },
     });
     workspacesFile;
+    // Track alive status for ping/pong keepalive
+    clientAlive = new WeakMap();
+    pingInterval;
     constructor(config = {}) {
         super();
         this.config = { ...DEFAULT_CONFIG, ...config };
@@ -73,6 +76,18 @@ export class Orchestrator extends EventEmitter {
         // Setup WebSocket
         this.wss = new WebSocketServer({ server: this.server });
         this.wss.on('connection', (ws, req) => this.handleWebSocket(ws, req));
+        // Setup ping/pong keepalive (30 second interval)
+        this.pingInterval = setInterval(() => {
+            this.wss?.clients.forEach((ws) => {
+                if (this.clientAlive.get(ws) === false) {
+                    logger.info('WebSocket client unresponsive, closing');
+                    ws.terminate();
+                    return;
+                }
+                this.clientAlive.set(ws, false);
+                ws.ping();
+            });
+        }, 30000);
         return new Promise((resolve) => {
             this.server.listen(this.config.port, this.config.host, () => {
                 logger.info('Orchestrator started', {
@@ -87,6 +102,11 @@ export class Orchestrator extends EventEmitter {
      */
     async stop() {
         logger.info('Stopping orchestrator');
+        // Clear ping interval
+        if (this.pingInterval) {
+            clearInterval(this.pingInterval);
+            this.pingInterval = undefined;
+        }
         // Stop all workspace daemons
         for (const [id] of this.workspaces) {
             await this.stopWorkspaceDaemon(id);
@@ -501,6 +521,12 @@ export class Orchestrator extends EventEmitter {
      */
     handleWebSocket(ws, _req) {
         logger.info('WebSocket client connected');
+        // Mark client as alive for ping/pong keepalive
+        this.clientAlive.set(ws, true);
+        // Handle pong responses
+        ws.on('pong', () => {
+            this.clientAlive.set(ws, true);
+        });
         const session = {
             userId: 'anonymous',
             githubUsername: 'anonymous',

package/dist/daemon/repo-manager.d.ts

@@ -0,0 +1,116 @@
+/**
+ * Workspace Repository Manager
+ *
+ * Manages repository cloning, updating, and removal for workspace containers.
+ * Uses a file-based tracking system (repos.json) to persist state across restarts.
+ *
+ * This replaces the static REPOSITORIES env var approach, allowing dynamic
+ * repo management without workspace restart.
+ */
+import { EventEmitter } from 'events';
+export interface RepoInfo {
+    /** Full GitHub repo name (e.g., "owner/repo") */
+    fullName: string;
+    /** Local directory name */
+    localName: string;
+    /** Absolute path to the cloned repo */
+    path: string;
+    /** Current status */
+    status: 'cloned' | 'cloning' | 'error' | 'removed';
+    /** Last sync timestamp */
+    lastSynced?: string;
+    /** Default branch */
+    defaultBranch?: string;
+    /** Error message if status is 'error' */
+    error?: string;
+    /** When the repo was added */
+    addedAt: string;
+}
+export interface ReposConfig {
+    version: number;
+    workspaceDir: string;
+    repos: Record<string, RepoInfo>;
+    lastUpdated: string;
+}
+export interface SyncResult {
+    success: boolean;
+    repo: string;
+    action: 'cloned' | 'updated' | 'already_synced' | 'error';
+    path?: string;
+    error?: string;
+}
+export interface RepoManagerConfig {
+    workspaceDir: string;
+    configFile?: string;
+}
+export declare class RepoManager extends EventEmitter {
+    private workspaceDir;
+    private configPath;
+    private config;
+    constructor(options: RepoManagerConfig);
+    /**
+     * Load or initialize the repos config file
+     */
+    private loadConfig;
+    /**
+     * Save the config to disk
+     */
+    private saveConfig;
+    /**
+     * Get all tracked repos
+     */
+    getRepos(): RepoInfo[];
+    /**
+     * Get a specific repo by full name
+     */
+    getRepo(fullName: string): RepoInfo | null;
+    /**
+     * Sync a repository (clone if new, pull if exists)
+     */
+    syncRepo(fullName: string): Promise<SyncResult>;
+    /**
+     * Remove a repository
+     */
+    removeRepo(fullName: string, deleteFiles?: boolean): Promise<boolean>;
+    /**
+     * Sync multiple repos (e.g., from initial REPOSITORIES env var)
+     */
+    syncRepos(fullNames: string[]): Promise<SyncResult[]>;
+    /**
+     * Initialize from REPOSITORIES env var (backward compatibility)
+     */
+    initFromEnv(): Promise<SyncResult[]>;
+    /**
+     * Scan workspace directory for existing repos and register them
+     * This handles repos that were cloned by entrypoint.sh before daemon started
+     */
+    scanExistingRepos(): void;
+    /**
+     * Clone a repository
+     */
+    private gitClone;
+    /**
+     * Pull updates for a repository
+     */
+    private gitPull;
+    /**
+     * Get the default branch of a repo
+     */
+    private getDefaultBranch;
+    /**
+     * Mark directory as safe for git (prevents "dubious ownership" errors)
+     */
+    private markSafeDirectory;
+}
+/**
+ * Get or create the repo manager instance
+ */
+export declare function getRepoManager(workspaceDir?: string): RepoManager;
+/**
+ * Initialize repo manager (call at startup)
+ *
+ * 1. Scans workspace for existing repos (handles entrypoint.sh clones)
+ * 2. Syncs any repos from REPOSITORIES env var that aren't already cloned
+ */
+export declare function initRepoManager(workspaceDir?: string): Promise<RepoManager>;
+//# sourceMappingURL=repo-manager.d.ts.map

package/dist/daemon/repo-manager.js

@@ -0,0 +1,384 @@
+/**
+ * Workspace Repository Manager
+ *
+ * Manages repository cloning, updating, and removal for workspace containers.
+ * Uses a file-based tracking system (repos.json) to persist state across restarts.
+ *
+ * This replaces the static REPOSITORIES env var approach, allowing dynamic
+ * repo management without workspace restart.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { execSync, spawn } from 'child_process';
+import { EventEmitter } from 'events';
+import { createLogger } from '../resiliency/logger.js';
+const logger = createLogger('repo-manager');
+const DEFAULT_CONFIG_FILE = 'repos.json';
+export class RepoManager extends EventEmitter {
+    workspaceDir;
+    configPath;
+    config;
+    constructor(options) {
+        super();
+        this.workspaceDir = options.workspaceDir;
+        this.configPath = path.join(this.workspaceDir, options.configFile || DEFAULT_CONFIG_FILE);
+        this.config = this.loadConfig();
+    }
+    /**
+     * Load or initialize the repos config file
+     */
+    loadConfig() {
+        try {
+            if (fs.existsSync(this.configPath)) {
+                const data = fs.readFileSync(this.configPath, 'utf-8');
+                const config = JSON.parse(data);
+                logger.info('Loaded repo config', { repoCount: Object.keys(config.repos).length });
+                return config;
+            }
+        }
+        catch (err) {
+            logger.warn('Failed to load repo config, starting fresh', { error: String(err) });
+        }
+        // Initialize new config
+        return {
+            version: 1,
+            workspaceDir: this.workspaceDir,
+            repos: {},
+            lastUpdated: new Date().toISOString(),
+        };
+    }
+    /**
+     * Save the config to disk
+     */
+    saveConfig() {
+        this.config.lastUpdated = new Date().toISOString();
+        fs.writeFileSync(this.configPath, JSON.stringify(this.config, null, 2));
+    }
+    /**
+     * Get all tracked repos
+     */
+    getRepos() {
+        return Object.values(this.config.repos).filter(r => r.status !== 'removed');
+    }
+    /**
+     * Get a specific repo by full name
+     */
+    getRepo(fullName) {
+        const key = fullName.toLowerCase();
+        return this.config.repos[key] || null;
+    }
+    /**
+     * Sync a repository (clone if new, pull if exists)
+     */
+    async syncRepo(fullName) {
+        const key = fullName.toLowerCase();
+        const localName = path.basename(fullName);
+        const repoPath = path.join(this.workspaceDir, localName);
+        logger.info('Syncing repo', { fullName, repoPath });
+        // Update status to cloning
+        this.config.repos[key] = {
+            fullName,
+            localName,
+            path: repoPath,
+            status: 'cloning',
+            addedAt: this.config.repos[key]?.addedAt || new Date().toISOString(),
+        };
+        this.saveConfig();
+        this.emit('repo:syncing', { fullName });
+        try {
+            const gitDir = path.join(repoPath, '.git');
+            const exists = fs.existsSync(gitDir);
+            if (exists) {
+                // Pull existing repo
+                await this.gitPull(repoPath, fullName);
+                this.config.repos[key] = {
+                    ...this.config.repos[key],
+                    status: 'cloned',
+                    lastSynced: new Date().toISOString(),
+                    defaultBranch: this.getDefaultBranch(repoPath),
+                    error: undefined,
+                };
+                this.saveConfig();
+                this.emit('repo:synced', { fullName, action: 'updated' });
+                logger.info('Repo updated', { fullName });
+                return { success: true, repo: fullName, action: 'updated', path: repoPath };
+            }
+            else {
+                // Clone new repo
+                await this.gitClone(fullName, repoPath);
+                this.config.repos[key] = {
+                    ...this.config.repos[key],
+                    status: 'cloned',
+                    lastSynced: new Date().toISOString(),
+                    defaultBranch: this.getDefaultBranch(repoPath),
+                    error: undefined,
+                };
+                this.saveConfig();
+                // Mark directory as safe for git
+                this.markSafeDirectory(repoPath);
+                this.emit('repo:synced', { fullName, action: 'cloned' });
+                logger.info('Repo cloned', { fullName });
+                return { success: true, repo: fullName, action: 'cloned', path: repoPath };
+            }
+        }
+        catch (err) {
+            const errorMsg = err instanceof Error ? err.message : String(err);
+            this.config.repos[key] = {
+                ...this.config.repos[key],
+                status: 'error',
+                error: errorMsg,
+            };
+            this.saveConfig();
+            this.emit('repo:error', { fullName, error: errorMsg });
+            logger.error('Repo sync failed', { fullName, error: errorMsg });
+            return { success: false, repo: fullName, action: 'error', error: errorMsg };
+        }
+    }
+    /**
+     * Remove a repository
+     */
+    async removeRepo(fullName, deleteFiles = false) {
+        const key = fullName.toLowerCase();
+        const repo = this.config.repos[key];
+        if (!repo) {
+            logger.warn('Repo not found for removal', { fullName });
+            return false;
+        }
+        logger.info('Removing repo', { fullName, deleteFiles });
+        if (deleteFiles && fs.existsSync(repo.path)) {
+            try {
+                fs.rmSync(repo.path, { recursive: true, force: true });
+                logger.info('Deleted repo files', { fullName, path: repo.path });
+            }
+            catch (err) {
+                logger.error('Failed to delete repo files', { fullName, error: String(err) });
+                // Continue anyway - mark as removed in config
+            }
+        }
+        // Mark as removed (or delete from config entirely)
+        if (deleteFiles) {
+            delete this.config.repos[key];
+        }
+        else {
+            this.config.repos[key] = {
+                ...repo,
+                status: 'removed',
+            };
+        }
+        this.saveConfig();
+        this.emit('repo:removed', { fullName });
+        return true;
+    }
+    /**
+     * Sync multiple repos (e.g., from initial REPOSITORIES env var)
+     */
+    async syncRepos(fullNames) {
+        const results = [];
+        for (const fullName of fullNames) {
+            if (!fullName.trim())
+                continue;
+            const result = await this.syncRepo(fullName.trim());
+            results.push(result);
+        }
+        return results;
+    }
+    /**
+     * Initialize from REPOSITORIES env var (backward compatibility)
+     */
+    async initFromEnv() {
+        const repoList = process.env.REPOSITORIES || '';
+        if (!repoList.trim()) {
+            logger.info('No REPOSITORIES env var set, skipping initial sync');
+            return [];
+        }
+        const repos = repoList.split(',').map(r => r.trim()).filter(Boolean);
+        logger.info('Initializing repos from env', { count: repos.length });
+        return this.syncRepos(repos);
+    }
+    /**
+     * Scan workspace directory for existing repos and register them
+     * This handles repos that were cloned by entrypoint.sh before daemon started
+     */
+    scanExistingRepos() {
+        try {
+            const entries = fs.readdirSync(this.workspaceDir, { withFileTypes: true });
+            for (const entry of entries) {
+                if (!entry.isDirectory())
+                    continue;
+                if (entry.name === DEFAULT_CONFIG_FILE || entry.name.startsWith('.'))
+                    continue;
+                const repoPath = path.join(this.workspaceDir, entry.name);
+                const gitDir = path.join(repoPath, '.git');
+                if (!fs.existsSync(gitDir))
+                    continue;
+                // Try to get the remote URL to determine full repo name
+                let fullName = entry.name; // Default to directory name
+                try {
+                    const remoteUrl = execSync('git config --get remote.origin.url', {
+                        cwd: repoPath,
+                        encoding: 'utf-8',
+                        stdio: ['ignore', 'pipe', 'ignore'],
+                    }).trim();
+                    // Parse GitHub URL: https://github.com/owner/repo.git or git@github.com:owner/repo.git
+                    const match = remoteUrl.match(/github\.com[/:]([a-zA-Z0-9_-]+)\/([a-zA-Z0-9_.-]+?)(?:\.git)?$/);
+                    if (match) {
+                        fullName = `${match[1]}/${match[2]}`;
+                    }
+                }
+                catch {
+                    // Couldn't get remote, use directory name
+                }
+                const key = fullName.toLowerCase();
+                // Only register if not already tracked
+                if (!this.config.repos[key]) {
+                    this.config.repos[key] = {
+                        fullName,
+                        localName: entry.name,
+                        path: repoPath,
+                        status: 'cloned',
+                        lastSynced: new Date().toISOString(),
+                        defaultBranch: this.getDefaultBranch(repoPath),
+                        addedAt: new Date().toISOString(),
+                    };
+                    logger.info('Registered existing repo', { fullName, path: repoPath });
+                }
+            }
+            this.saveConfig();
+        }
+        catch (err) {
+            logger.warn('Failed to scan for existing repos', { error: String(err) });
+        }
+    }
+    /**
+     * Clone a repository
+     */
+    gitClone(fullName, targetPath) {
+        return new Promise((resolve, reject) => {
+            const url = `https://github.com/${fullName}.git`;
+            logger.info('Cloning', { url, targetPath });
+            const proc = spawn('git', ['clone', url, targetPath], {
+                stdio: ['ignore', 'pipe', 'pipe'],
+                env: { ...process.env, GIT_TERMINAL_PROMPT: '0' },
+            });
+            let stderr = '';
+            proc.stderr?.on('data', (data) => {
+                stderr += data.toString();
+            });
+            proc.on('close', (code) => {
+                if (code === 0) {
+                    resolve();
+                }
+                else {
+                    reject(new Error(`git clone failed (code ${code}): ${stderr}`));
+                }
+            });
+            proc.on('error', (err) => {
+                reject(err);
+            });
+        });
+    }
+    /**
+     * Pull updates for a repository
+     */
+    gitPull(repoPath, fullName) {
+        return new Promise((resolve, reject) => {
+            logger.info('Pulling', { repoPath });
+            // First update remote URL in case it changed
+            try {
+                const url = `https://github.com/${fullName}.git`;
+                execSync(`git remote set-url origin "${url}"`, {
+                    cwd: repoPath,
+                    stdio: 'ignore',
+                });
+            }
+            catch {
+                // Ignore - remote might not exist yet
+            }
+            // Fetch and pull
+            const proc = spawn('git', ['pull', '--ff-only'], {
+                cwd: repoPath,
+                stdio: ['ignore', 'pipe', 'pipe'],
+                env: { ...process.env, GIT_TERMINAL_PROMPT: '0' },
+            });
+            let stderr = '';
+            proc.stderr?.on('data', (data) => {
+                stderr += data.toString();
+            });
+            proc.on('close', (code) => {
+                if (code === 0) {
+                    resolve();
+                }
+                else {
+                    // Try fetch --all as fallback (handles diverged branches better)
+                    try {
+                        execSync('git fetch --all --prune', { cwd: repoPath, stdio: 'ignore' });
+                        resolve();
+                    }
+                    catch {
+                        reject(new Error(`git pull failed (code ${code}): ${stderr}`));
+                    }
+                }
+            });
+            proc.on('error', (err) => {
+                reject(err);
+            });
+        });
+    }
+    /**
+     * Get the default branch of a repo
+     */
+    getDefaultBranch(repoPath) {
+        try {
+            const result = execSync('git symbolic-ref --short HEAD', {
+                cwd: repoPath,
+                encoding: 'utf-8',
+                stdio: ['ignore', 'pipe', 'ignore'],
+            });
+            return result.trim();
+        }
+        catch {
+            return 'main';
+        }
+    }
+    /**
+     * Mark directory as safe for git (prevents "dubious ownership" errors)
+     */
+    markSafeDirectory(repoPath) {
+        try {
+            execSync(`git config --global --add safe.directory "${repoPath}"`, {
+                stdio: 'ignore',
+            });
+        }
+        catch {
+            // Ignore errors
+        }
+    }
+}
+// Singleton instance
+let repoManagerInstance = null;
+/**
+ * Get or create the repo manager instance
+ */
+export function getRepoManager(workspaceDir) {
+    if (!repoManagerInstance) {
+        const dir = workspaceDir || process.env.WORKSPACE_DIR || '/workspace';
+        repoManagerInstance = new RepoManager({ workspaceDir: dir });
+    }
+    return repoManagerInstance;
+}
+/**
+ * Initialize repo manager (call at startup)
+ *
+ * 1. Scans workspace for existing repos (handles entrypoint.sh clones)
+ * 2. Syncs any repos from REPOSITORIES env var that aren't already cloned
+ */
+export async function initRepoManager(workspaceDir) {
+    const manager = getRepoManager(workspaceDir);
+    // First, scan for repos already cloned by entrypoint.sh
+    manager.scanExistingRepos();
+    // Then sync any additional repos from env var
+    // (syncRepos skips repos that are already cloned and up-to-date)
+    await manager.initFromEnv();
+    return manager;
+}
+//# sourceMappingURL=repo-manager.js.map