2e108b040f
* feat: session resumption with ACP session ID support - Add useSessionResumption hook for automatic session recovery on page reload - Fix ACPSessionID not being set on AgentInstance in Launch() and createInstance() - Add task.session.status and task.session.resume WebSocket actions - Fix shell terminal retry logic for resumed sessions - Fix taskSessionState reading from Zustand store instead of local state - Remove dead code: unused stream handling functions in lifecycle/manager.go - Fix test mock interfaces (CleanupStaleInstanceByTaskID, NewManager signature) - Add enhanced logging for session resumption debugging - Simplify page-client.tsx state merging logic * refactor: remove unused AgentController (dead code) - Delete agent_controller.go - entirely unused duplicate of Manager methods - Remove agentController field from Manager struct - Remove AgentController initialization in NewManager The AgentController duplicated StartAgentProcess, initializeACPSession, and PromptAgent from Manager but was never called. All agent control operations go through Manager's own methods. * refactor: remove unused MemoryRepository (dead code) - Delete memory.go - entire MemoryRepository implementation unused (replaced by SQLite repository) - Delete memory_test.go - tests for removed MemoryRepository Found via 'deadcode' tool analysis. * refactor: consolidate agentctl packages into server/client structure Reorganize the confusing dual agentctl packages: - internal/agentctl/* → internal/agentctl/server/ - internal/agent/agentctl/* → internal/agentctl/client/ Structure is now: internal/agentctl/ ├── client/ - HTTP client for talking to agentctl servers │ ├── client.go │ ├── standalone.go │ ├── acp.go │ └── launcher/ ├── server/ - agentctl server implementation (runs in containers) │ ├── api/ │ ├── adapter/ │ ├── acp/ │ ├── config/ │ ├── instance/ │ ├── process/ │ └── shell/ └── types/ - Shared types used by both client and server Also consolidated shared types (GitStatusUpdate, FileInfo, etc.) from process/types.go into the shared types/ package. * refactor: rename AgentInstance to AgentExecution for clarity Rename AgentInstance -> AgentExecution across the entire codebase to better reflect what it represents: an agent actively working on a task, not just a generic 'instance'. Changes: - AgentInstance struct -> AgentExecution - InstanceStore -> ExecutionStore (new file: execution_store.go) - RecoveredInstance -> RecoveredExecution - All method names: GetInstance* -> GetExecution*, ListInstances -> ListExecutions, etc. - All parameters: instanceID -> executionID - All local variables: instance -> execution - DTOs and JSON tags: agent_instance_id -> agent_execution_id - Database columns: agent_instance_id -> agent_execution_id Also consolidates duplicate prompt logic: - Merge sendInitialPrompt and SendPrompt into single SendPrompt method - Add validateStatus parameter to differentiate initial vs follow-up prompts Also extracts ACP session management to session.go: - Move initializeACPSession logic to SessionManager.InitializeAndPrompt - Move PromptAgent logic to SessionManager.SendPrompt - Manager now delegates to SessionManager for all prompt operations Also removes duplicate event publishing: - Remove 9 duplicate m.publish*() methods from manager.go - Use existing EventPublisher methods via m.eventPublisher.Publish*() Also extracts types to dedicated file: - Move AgentExecution, LaunchRequest, PromptResult, etc. to types.go Net reduction: ~600 lines removed from manager.go through deduplication and better separation of concerns. * fix(backend): Docker runtime now creates instance via ControlServer The Docker runtime was incorrectly creating an agentctl.Client pointing directly to port 9999 (the ControlServer port), then trying to call instance-specific APIs like /api/v1/agent/configure which only exist on per-instance servers. Fixed by making Docker runtime follow the same flow as standalone mode: - LaunchContainer now uses StandaloneCtl to create an instance via the control API, then creates Client pointing to the instance port - RecoverInstances queries the ControlServer to get the instance port - Added waitForHealth helper to wait for agentctl to be ready Also improved HTTP error handling in agentctl client: - All client methods now check HTTP status codes before JSON decoding - Better error messages include status code and response body * fix: restore session resumption imports and variables * fix: add sessionId prop back to TaskLayout
175 lines
5.2 KiB
TypeScript
175 lines
5.2 KiB
TypeScript
'use client';
|
|
|
|
import { useEffect, useRef, useCallback } from 'react';
|
|
import { Terminal } from '@xterm/xterm';
|
|
import { FitAddon } from '@xterm/addon-fit';
|
|
import '@xterm/xterm/css/xterm.css';
|
|
import { useAppStore, useAppStoreApi } from '@/components/state-provider';
|
|
import { getWebSocketClient } from '@/lib/ws/connection';
|
|
|
|
type ShellTerminalProps = {
|
|
taskId: string;
|
|
sessionId: string | null;
|
|
};
|
|
|
|
export function ShellTerminal({ taskId, sessionId }: ShellTerminalProps) {
|
|
const terminalRef = useRef<HTMLDivElement>(null);
|
|
const xtermRef = useRef<Terminal | null>(null);
|
|
const fitAddonRef = useRef<FitAddon | null>(null);
|
|
const lastOutputLengthRef = useRef(0);
|
|
const subscriptionIdRef = useRef(0);
|
|
const storeApi = useAppStoreApi();
|
|
|
|
const shellOutput = useAppStore((state) => state.shell.outputs[taskId] || '');
|
|
|
|
const send = useCallback(
|
|
(action: string, payload: Record<string, unknown>) => {
|
|
const client = getWebSocketClient();
|
|
if (client) {
|
|
client.send({ type: 'request', action, payload });
|
|
}
|
|
},
|
|
[]
|
|
);
|
|
|
|
// Initialize terminal
|
|
useEffect(() => {
|
|
if (!terminalRef.current || xtermRef.current) return;
|
|
|
|
const terminal = new Terminal({
|
|
cursorBlink: true,
|
|
fontSize: 13,
|
|
fontFamily: 'Menlo, Monaco, "Courier New", monospace',
|
|
theme: {
|
|
background: '#1e1e1e',
|
|
foreground: '#d4d4d4',
|
|
cursor: '#d4d4d4',
|
|
cursorAccent: '#1e1e1e',
|
|
selectionBackground: '#264f78',
|
|
black: '#1e1e1e',
|
|
red: '#f44747',
|
|
green: '#6a9955',
|
|
yellow: '#dcdcaa',
|
|
blue: '#569cd6',
|
|
magenta: '#c586c0',
|
|
cyan: '#4ec9b0',
|
|
white: '#d4d4d4',
|
|
brightBlack: '#808080',
|
|
brightRed: '#f44747',
|
|
brightGreen: '#6a9955',
|
|
brightYellow: '#dcdcaa',
|
|
brightBlue: '#569cd6',
|
|
brightMagenta: '#c586c0',
|
|
brightCyan: '#4ec9b0',
|
|
brightWhite: '#ffffff',
|
|
},
|
|
});
|
|
|
|
const fitAddon = new FitAddon();
|
|
terminal.loadAddon(fitAddon);
|
|
terminal.open(terminalRef.current);
|
|
fitAddon.fit();
|
|
|
|
xtermRef.current = terminal;
|
|
fitAddonRef.current = fitAddon;
|
|
|
|
// Handle user input
|
|
terminal.onData((data) => {
|
|
send('shell.input', { task_id: taskId, session_id: sessionId, data });
|
|
});
|
|
|
|
// Handle resize
|
|
const resizeObserver = new ResizeObserver(() => {
|
|
fitAddon.fit();
|
|
});
|
|
resizeObserver.observe(terminalRef.current);
|
|
|
|
return () => {
|
|
resizeObserver.disconnect();
|
|
terminal.dispose();
|
|
xtermRef.current = null;
|
|
fitAddonRef.current = null;
|
|
};
|
|
}, [taskId, sessionId, send]);
|
|
|
|
// Write new output to terminal
|
|
useEffect(() => {
|
|
if (!xtermRef.current) return;
|
|
|
|
// Only write new data since last update
|
|
const newData = shellOutput.slice(lastOutputLengthRef.current);
|
|
if (newData) {
|
|
xtermRef.current.write(newData);
|
|
lastOutputLengthRef.current = shellOutput.length;
|
|
}
|
|
}, [shellOutput]);
|
|
|
|
// Subscribe to shell on mount to start the shell stream
|
|
// Uses retry logic to handle cases where agent isn't ready yet (e.g., session resumption)
|
|
useEffect(() => {
|
|
// Increment subscription ID to invalidate any pending requests
|
|
const currentSubscriptionId = ++subscriptionIdRef.current;
|
|
let retryCount = 0;
|
|
const maxRetries = 10;
|
|
const retryDelay = 1000; // 1 second between retries
|
|
let retryTimeout: ReturnType<typeof setTimeout> | null = null;
|
|
|
|
// Clear any stale output before subscribing to get fresh buffer
|
|
storeApi.getState().clearShellOutput(taskId);
|
|
lastOutputLengthRef.current = 0;
|
|
|
|
// Also clear the terminal display
|
|
if (xtermRef.current) {
|
|
xtermRef.current.clear();
|
|
}
|
|
|
|
const attemptSubscribe = () => {
|
|
const client = getWebSocketClient();
|
|
if (!client) return;
|
|
|
|
// Check if this subscription is still valid
|
|
if (subscriptionIdRef.current !== currentSubscriptionId) return;
|
|
|
|
client
|
|
.request<{ success: boolean; buffer?: string }>('shell.subscribe', { task_id: taskId, session_id: sessionId })
|
|
.then((response) => {
|
|
// Only process if this is still the current subscription (handles React Strict Mode)
|
|
if (subscriptionIdRef.current !== currentSubscriptionId) return;
|
|
|
|
// Write buffered output from response
|
|
if (response.buffer) {
|
|
storeApi.getState().appendShellOutput(taskId, response.buffer);
|
|
}
|
|
})
|
|
.catch((err) => {
|
|
if (subscriptionIdRef.current !== currentSubscriptionId) return;
|
|
|
|
// Retry if agent not ready yet (common during session resumption)
|
|
if (retryCount < maxRetries) {
|
|
retryCount++;
|
|
console.log(`[ShellTerminal] Retrying shell subscription (${retryCount}/${maxRetries})...`);
|
|
retryTimeout = setTimeout(attemptSubscribe, retryDelay);
|
|
} else {
|
|
console.error('Failed to subscribe to shell after retries:', err);
|
|
}
|
|
});
|
|
};
|
|
|
|
attemptSubscribe();
|
|
|
|
return () => {
|
|
if (retryTimeout) {
|
|
clearTimeout(retryTimeout);
|
|
}
|
|
};
|
|
}, [taskId, sessionId, storeApi]);
|
|
|
|
return (
|
|
<div
|
|
ref={terminalRef}
|
|
className="h-full w-full overflow-hidden rounded-md border border-border bg-[#1e1e1e]"
|
|
/>
|
|
);
|
|
}
|
|
|