agent-relay 1.3.0 → 1.3.2

package/dist/cloud/services/nango.js

@@ -81,48 +81,26 @@ class NangoService {
      * This is the user-level token (not the installation token).
      * Use this for operations that require user context (e.g., gh CLI).
      *
-     * The user token can be found in:
-     * 1. getToken() without installation flag
-     * 2. connection_config.access_token in github-app-oauth
-     * 3. Separate 'github' user connection
+     * The user token is stored in connection_config.userCredentials.access_token
+     * by Nango's GitHub App OAuth flow. This is a gho_* or ghu_* token that
+     * works for both git operations and gh CLI commands.
      */
     async getGithubUserOAuthToken(connectionId) {
-        // First try: Get token from github-app-oauth connection credentials
-        try {
-            const token = await this.client.getToken(NANGO_INTEGRATIONS.GITHUB_APP, connectionId);
-            if (typeof token === 'string' && token.length > 0) {
-                return token;
-            }
-            if (token && typeof token === 'object') {
-                const tokenObj = token;
-                if (tokenObj.access_token) {
-                    return tokenObj.access_token;
-                }
-                if (tokenObj.token) {
-                    return tokenObj.token;
-                }
-            }
-        }
-        catch (err) {
-            console.log('[nango] getToken for user OAuth failed, trying connection_config:', err);
-        }
-        // Second try: Check connection_config for user token
         try {
             const connection = await this.client.getConnection(NANGO_INTEGRATIONS.GITHUB_APP, connectionId);
             const connConfig = connection.connection_config;
-            if (connConfig?.access_token && typeof connConfig.access_token === 'string') {
-                return connConfig.access_token;
-            }
-            // Also check credentials object
-            const credentials = connection.credentials;
-            if (credentials?.access_token) {
-                return credentials.access_token;
+            // Check for userCredentials.access_token (the user's personal OAuth token)
+            const userCredentials = connConfig?.userCredentials;
+            if (userCredentials?.access_token && typeof userCredentials.access_token === 'string') {
+                return userCredentials.access_token;
             }
+            throw new Error('No userCredentials.access_token in connection_config');
         }
         catch (err) {
-            console.log('[nango] connection_config check failed:', err);
+            const message = err instanceof Error ? err.message : 'Unknown error';
+            console.log('[nango] getGithubUserOAuthToken failed:', message);
+            throw new Error('Could not retrieve GitHub user OAuth token');
         }
-        throw new Error('Could not retrieve GitHub user OAuth token');
     }
     /**
      * Retrieve the user's OAuth token from a 'github' user connection.

package/dist/cloud/services/workspace-keepalive.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Workspace Keepalive Service
+ *
+ * Prevents Fly.io from idling workspace machines that have active agents running.
+ *
+ * Problem: Fly.io uses request-based concurrency tracking to determine when to
+ * idle a machine. If a Claude agent is running but no HTTP requests are coming
+ * in (e.g., no one has the dashboard open), Fly.io may idle the machine.
+ *
+ * Solution: The cloud server periodically pings workspace machines that have
+ * active agents. This inbound HTTP request counts as activity for Fly.io's
+ * idle detection, keeping the machine awake.
+ *
+ * Flow:
+ * 1. Daemons report their running agents via heartbeat
+ * 2. This service queries for workspaces with active agents
+ * 3. Pings each workspace's /keep-alive endpoint
+ * 4. Workspace stays awake as long as agents are active
+ */
+import { EventEmitter } from 'events';
+export interface WorkspaceKeepaliveConfig {
+    /** How often to ping active workspaces (default: 60s) */
+    pingIntervalMs: number;
+    /** Request timeout for keep-alive pings (default: 5s) */
+    requestTimeoutMs: number;
+    /** Consider daemon stale if last heartbeat older than this (default: 2 min) */
+    staleThresholdMs: number;
+    /** Enable verbose logging (default: false) */
+    verbose: boolean;
+}
+export interface KeepaliveStats {
+    lastRun: Date | null;
+    totalPings: number;
+    successfulPings: number;
+    failedPings: number;
+    activeWorkspaces: number;
+}
+export declare class WorkspaceKeepaliveService extends EventEmitter {
+    private config;
+    private pingTimer;
+    private stats;
+    constructor(config?: Partial<WorkspaceKeepaliveConfig>);
+    /**
+     * Start the keepalive service
+     */
+    start(): void;
+    /**
+     * Stop the keepalive service
+     */
+    stop(): void;
+    /**
+     * Get current statistics
+     */
+    getStats(): KeepaliveStats;
+    /**
+     * Find workspaces with active agents and ping them
+     */
+    pingActiveWorkspaces(): Promise<void>;
+    /**
+     * Find all workspaces that have daemons with active agents
+     */
+    private findWorkspacesWithActiveAgents;
+    /**
+     * Ping a single workspace's keep-alive endpoint
+     */
+    private pingWorkspace;
+}
+/**
+ * Get or create the keepalive service singleton
+ */
+export declare function getWorkspaceKeepaliveService(config?: Partial<WorkspaceKeepaliveConfig>): WorkspaceKeepaliveService;
+/**
+ * Create a new keepalive service (for testing)
+ */
+export declare function createWorkspaceKeepaliveService(config?: Partial<WorkspaceKeepaliveConfig>): WorkspaceKeepaliveService;
+//# sourceMappingURL=workspace-keepalive.d.ts.map

package/dist/cloud/services/workspace-keepalive.js

@@ -0,0 +1,234 @@
+/**
+ * Workspace Keepalive Service
+ *
+ * Prevents Fly.io from idling workspace machines that have active agents running.
+ *
+ * Problem: Fly.io uses request-based concurrency tracking to determine when to
+ * idle a machine. If a Claude agent is running but no HTTP requests are coming
+ * in (e.g., no one has the dashboard open), Fly.io may idle the machine.
+ *
+ * Solution: The cloud server periodically pings workspace machines that have
+ * active agents. This inbound HTTP request counts as activity for Fly.io's
+ * idle detection, keeping the machine awake.
+ *
+ * Flow:
+ * 1. Daemons report their running agents via heartbeat
+ * 2. This service queries for workspaces with active agents
+ * 3. Pings each workspace's /keep-alive endpoint
+ * 4. Workspace stays awake as long as agents are active
+ */
+import { EventEmitter } from 'events';
+import { db } from '../db/index.js';
+const DEFAULT_CONFIG = {
+    pingIntervalMs: 60_000, // 1 minute (well under Fly's ~5-10 min idle timeout)
+    requestTimeoutMs: 5_000, // 5 seconds
+    staleThresholdMs: 2 * 60 * 1000, // 2 minutes
+    verbose: false,
+};
+export class WorkspaceKeepaliveService extends EventEmitter {
+    config;
+    pingTimer = null;
+    stats = {
+        lastRun: null,
+        totalPings: 0,
+        successfulPings: 0,
+        failedPings: 0,
+        activeWorkspaces: 0,
+    };
+    constructor(config = {}) {
+        super();
+        this.config = { ...DEFAULT_CONFIG, ...config };
+    }
+    /**
+     * Start the keepalive service
+     */
+    start() {
+        if (this.pingTimer) {
+            return; // Already running
+        }
+        console.log('[keepalive] Starting workspace keepalive service', {
+            intervalMs: this.config.pingIntervalMs,
+        });
+        // Initial ping
+        this.pingActiveWorkspaces().catch((err) => {
+            console.error('[keepalive] Initial ping failed:', err);
+        });
+        // Start periodic pings
+        this.pingTimer = setInterval(() => {
+            this.pingActiveWorkspaces().catch((err) => {
+                console.error('[keepalive] Periodic ping failed:', err);
+            });
+        }, this.config.pingIntervalMs);
+    }
+    /**
+     * Stop the keepalive service
+     */
+    stop() {
+        if (this.pingTimer) {
+            clearInterval(this.pingTimer);
+            this.pingTimer = null;
+            console.log('[keepalive] Stopped workspace keepalive service');
+        }
+    }
+    /**
+     * Get current statistics
+     */
+    getStats() {
+        return { ...this.stats };
+    }
+    /**
+     * Find workspaces with active agents and ping them
+     */
+    async pingActiveWorkspaces() {
+        const startTime = Date.now();
+        try {
+            // Find workspaces with active agents
+            const activeWorkspaces = await this.findWorkspacesWithActiveAgents();
+            this.stats.activeWorkspaces = activeWorkspaces.length;
+            this.stats.lastRun = new Date();
+            if (activeWorkspaces.length === 0) {
+                if (this.config.verbose) {
+                    console.log('[keepalive] No active workspaces to ping');
+                }
+                return;
+            }
+            if (this.config.verbose) {
+                console.log(`[keepalive] Pinging ${activeWorkspaces.length} active workspace(s)`);
+            }
+            // Ping each workspace in parallel
+            const results = await Promise.allSettled(activeWorkspaces.map((ws) => this.pingWorkspace(ws)));
+            // Update stats
+            for (const result of results) {
+                this.stats.totalPings++;
+                if (result.status === 'fulfilled' && result.value) {
+                    this.stats.successfulPings++;
+                }
+                else {
+                    this.stats.failedPings++;
+                }
+            }
+            const duration = Date.now() - startTime;
+            if (this.config.verbose) {
+                console.log(`[keepalive] Ping cycle complete`, {
+                    workspaces: activeWorkspaces.length,
+                    durationMs: duration,
+                });
+            }
+            this.emit('ping-cycle', {
+                workspaces: activeWorkspaces.length,
+                duration,
+                results: results.map((r) => r.status === 'fulfilled' && r.value),
+            });
+        }
+        catch (err) {
+            console.error('[keepalive] Error in ping cycle:', err);
+            this.emit('error', err);
+        }
+    }
+    /**
+     * Find all workspaces that have daemons with active agents
+     */
+    async findWorkspacesWithActiveAgents() {
+        const staleThreshold = new Date(Date.now() - this.config.staleThresholdMs);
+        // Get all workspaces and check each for active agents
+        const allWorkspaces = await db.workspaces.findAll();
+        const activeWorkspaces = [];
+        for (const workspace of allWorkspaces) {
+            // Skip workspaces that aren't running or don't have a URL
+            if (workspace.status !== 'running' || !workspace.publicUrl) {
+                continue;
+            }
+            // Get daemons for this workspace
+            const daemons = await db.linkedDaemons.findByWorkspaceId(workspace.id);
+            for (const daemon of daemons) {
+                // Skip offline daemons or those with stale heartbeats
+                if (daemon.status !== 'online')
+                    continue;
+                if (daemon.lastSeenAt && daemon.lastSeenAt < staleThreshold)
+                    continue;
+                // Check if daemon has any active agents
+                const metadata = daemon.metadata;
+                const agents = metadata?.agents || [];
+                // Count agents that appear to be active (not offline/disconnected)
+                const activeAgents = agents.filter((a) => a.status === 'online' || a.status === 'running' || a.status === 'active');
+                if (activeAgents.length > 0) {
+                    activeWorkspaces.push({
+                        workspaceId: workspace.id,
+                        publicUrl: workspace.publicUrl,
+                        daemonId: daemon.id,
+                        daemonName: daemon.name,
+                        agentCount: activeAgents.length,
+                    });
+                    // Only need one daemon per workspace to keep it alive
+                    break;
+                }
+            }
+        }
+        return activeWorkspaces;
+    }
+    /**
+     * Ping a single workspace's keep-alive endpoint
+     */
+    async pingWorkspace(workspace) {
+        const url = `${workspace.publicUrl.replace(/\/$/, '')}/keep-alive`;
+        try {
+            const controller = new AbortController();
+            const timeout = setTimeout(() => controller.abort(), this.config.requestTimeoutMs);
+            const response = await fetch(url, {
+                method: 'GET',
+                signal: controller.signal,
+                headers: {
+                    'User-Agent': 'AgentRelay-Keepalive/1.0',
+                },
+            });
+            clearTimeout(timeout);
+            if (response.ok) {
+                const data = await response.json();
+                if (this.config.verbose) {
+                    console.log(`[keepalive] Pinged ${workspace.daemonName}`, {
+                        workspaceId: workspace.workspaceId,
+                        activeAgents: data.activeAgents,
+                    });
+                }
+                return true;
+            }
+            else {
+                console.warn(`[keepalive] Ping failed for ${workspace.daemonName}:`, {
+                    status: response.status,
+                    url,
+                });
+                return false;
+            }
+        }
+        catch (err) {
+            // Don't log aborted requests as errors (timeout is expected for stopped machines)
+            if (err instanceof Error && err.name === 'AbortError') {
+                if (this.config.verbose) {
+                    console.log(`[keepalive] Ping timeout for ${workspace.daemonName} (machine may be starting)`);
+                }
+            }
+            else {
+                console.warn(`[keepalive] Ping error for ${workspace.daemonName}:`, err);
+            }
+            return false;
+        }
+    }
+}
+// Singleton instance
+let _keepaliveService = null;
+/**
+ * Get or create the keepalive service singleton
+ */
+export function getWorkspaceKeepaliveService(config) {
+    if (!_keepaliveService) {
+        _keepaliveService = new WorkspaceKeepaliveService(config);
+    }
+    return _keepaliveService;
+}
+/**
+ * Create a new keepalive service (for testing)
+ */
+export function createWorkspaceKeepaliveService(config) {
+    return new WorkspaceKeepaliveService(config);
+}
+//# sourceMappingURL=workspace-keepalive.js.map

package/dist/config/relay-config.d.ts

@@ -0,0 +1,23 @@
+export declare const DEFAULT_CONNECTION_CONFIG: {
+    readonly maxFrameBytes: number;
+    readonly heartbeatMs: 5000;
+    readonly heartbeatTimeoutMultiplier: 6;
+    readonly maxWriteQueueSize: 2000;
+    readonly writeQueueHighWaterMark: 1500;
+    readonly writeQueueLowWaterMark: 500;
+};
+export declare const DEFAULT_TMUX_WRAPPER_CONFIG: {
+    readonly pollInterval: 200;
+    readonly idleBeforeInjectMs: 1500;
+    readonly injectRetryMs: 500;
+    readonly debug: false;
+    readonly debugLogIntervalMs: 0;
+    readonly mouseMode: true;
+    readonly activityIdleThresholdMs: 30000;
+    readonly outputStabilityTimeoutMs: 2000;
+    readonly outputStabilityPollMs: 200;
+    readonly streamLogs: true;
+};
+export declare const DEFAULT_IDLE_BEFORE_INJECT_MS = 1500;
+export declare const DEFAULT_IDLE_CONFIDENCE_THRESHOLD = 0.7;
+//# sourceMappingURL=relay-config.d.ts.map

package/dist/config/relay-config.js

@@ -0,0 +1,23 @@
+export const DEFAULT_CONNECTION_CONFIG = {
+    maxFrameBytes: 1024 * 1024,
+    heartbeatMs: 5000,
+    heartbeatTimeoutMultiplier: 6,
+    maxWriteQueueSize: 2000,
+    writeQueueHighWaterMark: 1500,
+    writeQueueLowWaterMark: 500,
+};
+export const DEFAULT_TMUX_WRAPPER_CONFIG = {
+    pollInterval: 200,
+    idleBeforeInjectMs: 1500,
+    injectRetryMs: 500,
+    debug: false,
+    debugLogIntervalMs: 0,
+    mouseMode: true,
+    activityIdleThresholdMs: 30_000,
+    outputStabilityTimeoutMs: 2000,
+    outputStabilityPollMs: 200,
+    streamLogs: true,
+};
+export const DEFAULT_IDLE_BEFORE_INJECT_MS = 1500;
+export const DEFAULT_IDLE_CONFIDENCE_THRESHOLD = 0.7;
+//# sourceMappingURL=relay-config.js.map

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

@@ -3,7 +3,7 @@
  * Manages agents across workspaces with integrated resiliency.
  */
 import { EventEmitter } from 'events';
-import { type SummaryEvent, type SessionEndEvent } from '../wrapper/pty-wrapper.js';
+import { PtyWrapper, type SummaryEvent, type SessionEndEvent } from '../wrapper/pty-wrapper.js';
 import type { Agent, SpawnAgentRequest } from './types.js';
 /**
  * Optional cloud persistence handler.
@@ -15,6 +15,9 @@ export interface CloudPersistenceHandler {
     /** Optional cleanup method for tests and graceful shutdown */
     destroy?: () => void;
 }
+interface ManagedAgent extends Agent {
+    pty?: PtyWrapper;
+}
 export declare class AgentManager extends EventEmitter {
     private agents;
     private supervisor;
@@ -72,6 +75,21 @@ export declare class AgentManager extends EventEmitter {
      * Send input to an agent
      */
     sendInput(agentId: string, input: string): boolean;
+    /**
+     * Interrupt an agent by sending Escape key twice.
+     * This breaks the agent out of their current task to allow refocusing.
+     * Uses Escape instead of Ctrl+C for better CLI compatibility (e.g., Claude CLI).
+     */
+    interrupt(agentId: string): boolean;
+    /**
+     * Find agent by name (global search across all workspaces)
+     */
+    findAgentByName(name: string): ManagedAgent | undefined;
+    /**
+     * Interrupt an agent by name (searches across all workspaces).
+     * Useful for dashboard where only agent name is available.
+     */
+    interruptByName(name: string): boolean;
     /**
      * Restart an agent
      */
@@ -111,4 +129,5 @@ export declare class AgentManager extends EventEmitter {
     shutdown(): Promise<void>;
 }
 export declare function getAgentManager(dataDir?: string): AgentManager;
+export {};
 //# sourceMappingURL=agent-manager.d.ts.map

package/dist/daemon/agent-manager.js

@@ -97,6 +97,12 @@ export class AgentManager extends EventEmitter {
                 args,
                 cwd: workspacePath,
                 logsDir: this.logsDir,
+                env: {
+                    CLOUD_API_URL: process.env.CLOUD_API_URL || '',
+                    WORKSPACE_TOKEN: process.env.WORKSPACE_TOKEN || '',
+                    WORKSPACE_ID: workspaceId,
+                    ...process.env,
+                },
                 onExit: (code) => {
                     logger.info('Agent process exited', { name, code });
                     this.handleAgentExit(agent.id, code);
@@ -271,6 +277,41 @@ export class AgentManager extends EventEmitter {
         agent.pty.write(input);
         return true;
     }
+    /**
+     * Interrupt an agent by sending Escape key twice.
+     * This breaks the agent out of their current task to allow refocusing.
+     * Uses Escape instead of Ctrl+C for better CLI compatibility (e.g., Claude CLI).
+     */
+    interrupt(agentId) {
+        const agent = this.agents.get(agentId);
+        if (!agent?.pty)
+            return false;
+        logger.info('Interrupting agent', { id: agentId, name: agent.name });
+        // Send Escape key twice (ASCII 0x1b) to interrupt current operation
+        // Double Escape ensures the CLI exits any nested mode/prompt
+        agent.pty.write('\x1b\x1b');
+        return true;
+    }
+    /**
+     * Find agent by name (global search across all workspaces)
+     */
+    findAgentByName(name) {
+        return Array.from(this.agents.values()).find((a) => a.name === name);
+    }
+    /**
+     * Interrupt an agent by name (searches across all workspaces).
+     * Useful for dashboard where only agent name is available.
+     */
+    interruptByName(name) {
+        const agent = this.findAgentByName(name);
+        if (!agent?.pty)
+            return false;
+        logger.info('Interrupting agent by name', { name, id: agent.id });
+        // Send Escape key twice (ASCII 0x1b) to interrupt current operation
+        // Double Escape ensures the CLI exits any nested mode/prompt
+        agent.pty.write('\x1b\x1b');
+        return true;
+    }
     /**
      * Restart an agent
      */
@@ -300,6 +341,12 @@ export class AgentManager extends EventEmitter {
                 args,
                 cwd: workspacePath,
                 logsDir: this.logsDir,
+                env: {
+                    CLOUD_API_URL: process.env.CLOUD_API_URL || '',
+                    WORKSPACE_TOKEN: process.env.WORKSPACE_TOKEN || '',
+                    WORKSPACE_ID: agent.workspaceId,
+                    ...process.env,
+                },
                 onExit: (code) => {
                     this.handleAgentExit(agent.id, code);
                 },

package/dist/daemon/agent-registry.js

@@ -4,7 +4,7 @@
  */
 import fs from 'node:fs';
 import path from 'node:path';
-import { v4 as uuid } from 'uuid';
+import { generateId } from '../utils/id-generator.js';
 import { createLogger } from '../utils/logger.js';
 const log = createLogger('registry');
 export class AgentRegistry {
@@ -48,7 +48,7 @@ export class AgentRegistry {
             return updated;
         }
         const record = {
-            id: `agent-${uuid()}`,
+            id: `agent-${generateId()}`,
             name: agent.name,
             cli: agent.cli,
             program: agent.program,
@@ -138,7 +138,7 @@ export class AgentRegistry {
             return existing;
         const now = new Date().toISOString();
         const record = {
-            id: `agent-${uuid()}`,
+            id: `agent-${generateId()}`,
             name: agentName,
             firstSeen: now,
             lastSeen: now,
@@ -168,7 +168,7 @@ export class AgentRegistry {
                 if (!raw?.name)
                     continue;
                 const record = {
-                    id: raw.id ?? `agent-${uuid()}`,
+                    id: raw.id ?? `agent-${generateId()}`,
                     name: raw.name,
                     cli: raw.cli,
                     program: raw.program,